@zeniai/client-epic-state 5.0.74 → 5.0.75

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

@@ -3,7 +3,7 @@ import recordGet from 'lodash/get';
 import uniq from 'lodash/uniq';
 import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { isVendorTransaction } from '../../../entity/transaction/stateTypes/vendorTransaction';
-import { MAX_SELECTION_LIMIT, checkIfAllLineItemsAreCategoryClassFilled, filterAutoTabLineItems, mergeTabSpecificLineItems, removeTransactionFromTabView, setEntityRecommendationForLineIdInLocalData, toSetAllLineItemsToCategoryClass, toTransactionDetailLocalData, } from '../helpers/transactionCategorizationLocalDataHelper';
+import { filterAutoTabLineItems, mergeTabSpecificLineItems, removeTransactionFromTabView, setEntityRecommendationForLineIdInLocalData, shouldAutoSelectAndAdd, toSetAllLineItemsToCategoryClass, toTransactionDetailLocalData, } from '../helpers/transactionCategorizationLocalDataHelper';
 import { DEFAULT_COMPLETED_SUB_TAB, } from '../types/completedSubTab';
 export const initialTransactionTabViewState = {
     saveStatus: {
@@ -430,12 +430,9 @@ const expenseAutomationTransactionsView = createSlice({
                     const selectedCheckBoxTransactionIds = draft.transactionCategorizationView[selectedTab]
                         .selectedCheckBoxTransactionIds;
                     if (selectedTransaction != null &&
-                        checkIfAllLineItemsAreCategoryClassFilled(selectedTransaction, newTransactionLocalData, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) === true && // check if all line items are filled
-                        selectedCheckBoxTransactionIds.length < MAX_SELECTION_LIMIT &&
-                        selectedCheckBoxTransactionIds.includes(transactionId) === false) {
+                        shouldAutoSelectAndAdd(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled)) {
                         draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
-                            ...draft.transactionCategorizationView[selectedTab]
-                                .selectedCheckBoxTransactionIds,
+                            ...selectedCheckBoxTransactionIds,
                             transactionId,
                         ];
                     }
@@ -518,9 +515,26 @@ const expenseAutomationTransactionsView = createSlice({
                 const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
                     .transactionReviewLocalDataById, transactionId.id, undefined);
                 if (transactionLocalData != null) {
+                    const newLocalData = setEntityRecommendationForLineIdInLocalData(draft.transactionCategorizationView[selectedTab], transaction, transactionLocalData.transactionReviewLocalData, entity, lineIds, uncategorizedAccounts, action.payload.recommendationWithCOTByLineId, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled);
+                    // Release the per-line fetch flag for every line this fetch
+                    // covered. Done in-place on the freshly returned local data
+                    // (the helper produces a new mutable object), before we write
+                    // it back to the draft.
+                    lineIds.forEach((lineId) => {
+                        const lineItem = newLocalData.lineItemById[lineId];
+                        if (lineItem != null) {
+                            newLocalData.lineItemById[lineId] = {
+                                ...lineItem,
+                                categoryClassRecommendationsFetchState: {
+                                    fetchState: 'Completed',
+                                    error: undefined,
+                                },
+                            };
+                        }
+                    });
                     draft.transactionCategorizationView[selectedTab].transactionReviewLocalDataById[transaction.id] = {
                         transactionId: transaction.id,
-                        transactionReviewLocalData: setEntityRecommendationForLineIdInLocalData(draft.transactionCategorizationView[selectedTab], transaction, transactionLocalData.transactionReviewLocalData, entity, lineIds, uncategorizedAccounts, action.payload.recommendationWithCOTByLineId, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled),
+                        transactionReviewLocalData: newLocalData,
                     };
                     // Mark transaction as dirty (autofill happened)
                     if (!draft.transactionCategorizationView[selectedTab].transactionIdsWithUnsavedData.includes(transaction.id)) {
@@ -533,6 +547,99 @@ const expenseAutomationTransactionsView = createSlice({
                 }
             },
         },
+        // Start arm of the line-update recommendations fetch. Flips covered
+        // lines to In-Progress AND removes the transaction from
+        // selectedCheckBoxTransactionIds — the row is unchecked + disabled
+        // until either the success arm (recheck if limit allows) or the
+        // failure arm releases the per-line flag.
+        markCategoryClassRecommendationsInProgressForCategorization: {
+            reducer(draft, action) {
+                const { selectedTab, transactionId, lineIds } = action.payload;
+                const tab = draft.transactionCategorizationView[selectedTab];
+                const transactionLocalData = recordGet(tab.transactionReviewLocalDataById, transactionId.id, undefined);
+                if (transactionLocalData != null) {
+                    lineIds.forEach((lineId) => {
+                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
+                        if (lineItem != null) {
+                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
+                                ...lineItem,
+                                categoryClassRecommendationsFetchState: {
+                                    fetchState: 'In-Progress',
+                                    error: undefined,
+                                },
+                            };
+                        }
+                    });
+                }
+                // Uncheck on fetch start: the row's existing category/class are
+                // stale after a payee change, so we drop the auto-selection until
+                // fresh recommendations land.
+                if (tab.selectedCheckBoxTransactionIds.includes(transactionId.id)) {
+                    tab.selectedCheckBoxTransactionIds =
+                        tab.selectedCheckBoxTransactionIds.filter((id) => id !== transactionId.id);
+                }
+            },
+            prepare(selectedTab, transactionId, lineIds) {
+                return { payload: { selectedTab, transactionId, lineIds } };
+            },
+        },
+        // Completed arm. Used by the epic when the HTTP call succeeds but the
+        // server returned no per-line recommendations — we still need to
+        // release the In-Progress flag so the skeleton resolves. Successful
+        // responses with recommendations go through
+        // setEntityRecommendationForLineIdsForCategorization instead (which
+        // also flips the lines to Completed).
+        markCategoryClassRecommendationsCompletedForCategorization: {
+            reducer(draft, action) {
+                const { selectedTab, transactionId, lineIds } = action.payload;
+                const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
+                    .transactionReviewLocalDataById, transactionId.id, undefined);
+                if (transactionLocalData != null) {
+                    lineIds.forEach((lineId) => {
+                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
+                        if (lineItem != null) {
+                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
+                                ...lineItem,
+                                categoryClassRecommendationsFetchState: {
+                                    fetchState: 'Completed',
+                                    error: undefined,
+                                },
+                            };
+                        }
+                    });
+                }
+            },
+            prepare(selectedTab, transactionId, lineIds) {
+                return { payload: { selectedTab, transactionId, lineIds } };
+            },
+        },
+        // Failure arm. Flips covered lines to Error so the skeleton resolves
+        // and downstream UI can react to the failure. The transaction stays
+        // unchecked from the start-arm action.
+        markCategoryClassRecommendationsFailureForCategorization: {
+            reducer(draft, action) {
+                const { selectedTab, transactionId, lineIds, error } = action.payload;
+                const transactionLocalData = recordGet(draft.transactionCategorizationView[selectedTab]
+                    .transactionReviewLocalDataById, transactionId.id, undefined);
+                if (transactionLocalData != null) {
+                    lineIds.forEach((lineId) => {
+                        const lineItem = transactionLocalData.transactionReviewLocalData.lineItemById[lineId];
+                        if (lineItem != null) {
+                            transactionLocalData.transactionReviewLocalData.lineItemById[lineId] = {
+                                ...lineItem,
+                                categoryClassRecommendationsFetchState: {
+                                    fetchState: 'Error',
+                                    error,
+                                },
+                            };
+                        }
+                    });
+                }
+            },
+            prepare(selectedTab, transactionId, lineIds, error) {
+                return { payload: { selectedTab, transactionId, lineIds, error } };
+            },
+        },
         fetchTransactionCategorizationSuccess(draft, action) {
             const { selectedTab, refreshViewInBackground } = action.payload;
             if (draft.transactionCategorizationView[selectedTab].fetchState ===
@@ -628,9 +735,7 @@ const expenseAutomationTransactionsView = createSlice({
                     .selectedCheckBoxTransactionIds;
                 if (newTransactionLocalData.customer != null &&
                     newTransactionLocalData.customer.id != null &&
-                    checkIfAllLineItemsAreCategoryClassFilled(selectedTransaction, newTransactionLocalData, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) === true && // check if all line items are filled
-                    selectedCheckBoxTransactionIds.length < MAX_SELECTION_LIMIT &&
-                    selectedCheckBoxTransactionIds.includes(transactionId) === false) {
+                    shouldAutoSelectAndAdd(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled)) {
                     draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
                         ...selectedCheckBoxTransactionIds,
                         transactionId,
@@ -704,9 +809,7 @@ const expenseAutomationTransactionsView = createSlice({
                     .selectedCheckBoxTransactionIds;
                 if (newTransactionLocalData.vendor != null &&
                     newTransactionLocalData.vendor.id != null &&
-                    checkIfAllLineItemsAreCategoryClassFilled(selectedTransaction, newTransactionLocalData, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled) === true && // check if all line items are filled
-                    selectedCheckBoxTransactionIds.length < MAX_SELECTION_LIMIT &&
-                    selectedCheckBoxTransactionIds.includes(transactionId) === false) {
+                    shouldAutoSelectAndAdd(selectedTransaction, newTransactionLocalData, selectedCheckBoxTransactionIds, uncategorizedAccounts, isUncategorizedExpenseCategoryEnabled, isAccountingClassesEnabled)) {
                     draft.transactionCategorizationView[selectedTab].selectedCheckBoxTransactionIds = [
                         ...selectedCheckBoxTransactionIds,
                         transactionId,
@@ -939,5 +1042,5 @@ const expenseAutomationTransactionsView = createSlice({
         },
     },
 });
-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, 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, updateTransactionCategorizationUploadReceiptState, uploadTransactionCategorizationReceiptSuccess, } = expenseAutomationTransactionsView.actions;
 export default expenseAutomationTransactionsView.reducer;

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

@@ -1,3 +1,4 @@
+import { createSelector } from '@reduxjs/toolkit';
 import omit from 'lodash/omit';
 import { reduceAllFetchState, reduceAnyFetchState, } from '../../../commonStateTypes/reduceFetchState';
 import { toMonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
@@ -9,6 +10,59 @@ import { getAccountList, getNestedAccountListHierarchy, getUncategorizedAccounts
 import { getClassList, getNestedClassListHierarchy, } from '../../classList/classListSelector';
 import { getProjectList } from '../../projectList/projectListSelector';
 import { getAllSteps } from '../selectorTypes/expenseAutomationViewSelectorTypes';
+// Walks the tab's transactionReviewLocalDataById map and returns
+// `{ [transactionId]: true }` for every transaction that has at least
+// one line whose targeted-fetch is In-Progress. Pulled out as a plain
+// function so each tab's createSelector can share it.
+const computeCategorizationInFlightRecommendations = (transactionReviewLocalDataById) => {
+    const result = {};
+    if (transactionReviewLocalDataById == null) {
+        return result;
+    }
+    for (const [transactionId, data] of Object.entries(transactionReviewLocalDataById)) {
+        const lineItems = Object.values(data.transactionReviewLocalData.lineItemById);
+        if (lineItems.some((lineItem) => lineItem.categoryClassRecommendationsFetchState?.fetchState ===
+            'In-Progress')) {
+            result[transactionId] = true;
+        }
+    }
+    return result;
+};
+// Per-tab createSelector instances. Each one is memoized on its OWN tab's
+// transactionReviewLocalDataById reference. Switching tabs A->B->A no
+// longer busts the memo for tab A — the dispatcher below just returns
+// whichever per-tab selector matches the active tab, and reselect keeps
+// the prior result alive as long as the underlying slice ref is stable.
+const getReviewInFlightRecommendationsByTransactionId = createSelector((state) => state.expenseAutomationTransactionsViewState.transactionCategorizationView
+    .review.transactionReviewLocalDataById, computeCategorizationInFlightRecommendations);
+const getAutoCategorizedInFlightRecommendationsByTransactionId = createSelector((state) => state.expenseAutomationTransactionsViewState.transactionCategorizationView
+    .autoCategorized.transactionReviewLocalDataById, computeCategorizationInFlightRecommendations);
+// Per-transaction "any line is fetching category/class recommendations?"
+// map for the active categorization tab. Dispatches to the per-tab
+// memoized selector above so steady state (no fetches in flight)
+// recomputes only when the active tab's local data changes; tab switches
+// are O(1) cache lookups.
+//
+// `default` guards against the union "lying" at runtime: `TransactionsTab`
+// is produced via `stringToUnion`, which falls back to `s as StringUnion`
+// for unrecognized strings, so an unexpected value can land in state. The
+// downstream `getCategorizationHasInFlightRecommendations` calls
+// `Object.keys` on this result, so we must always return an object.
+export const getCategorizationInFlightRecommendationsByTransactionId = (state) => {
+    const tab = state.expenseAutomationTransactionsViewState
+        .selectedTransactionCategorizationTab;
+    switch (tab) {
+        case 'review':
+            return getReviewInFlightRecommendationsByTransactionId(state);
+        case 'autoCategorized':
+            return getAutoCategorizedInFlightRecommendationsByTransactionId(state);
+        default:
+            return {};
+    }
+};
+// Page-level "any line on the active tab is in flight?" flag. Drives the
+// list-page Save disable.
+export const getCategorizationHasInFlightRecommendations = createSelector(getCategorizationInFlightRecommendationsByTransactionId, (inFlightByTransactionId) => Object.keys(inFlightByTransactionId).length > 0);
 export const toTransactionView = (transaction, transactionLocalData) => {
     return {
         id: transaction.id,
@@ -160,6 +214,8 @@ export function getExpenseAutomationTransactionView(state) {
         : [];
     const transactionCompletionStatus = allSteps.find((step) => step.step === 'transaction_categorization')?.completionStatus;
     const completionStatus = transactionCompletionStatus ?? 'incomplete';
+    const inFlightCategoryClassRecommendationsByTransactionId = getCategorizationInFlightRecommendationsByTransactionId(state);
+    const hasInFlightCategoryClassRecommendations = getCategorizationHasInFlightRecommendations(state);
     return {
         version: 0,
         fetchState: fetchStatus.fetchState,
@@ -173,6 +229,8 @@ export function getExpenseAutomationTransactionView(state) {
         classList: allClasses,
         accountsHierarchyList,
         classHierarchyList,
+        hasInFlightCategoryClassRecommendations,
+        inFlightCategoryClassRecommendationsByTransactionId,
         isAccountingProjectsEnabled,
         projectList,
         transactionLocalData: filteredTransactionLocalData,

package/lib/esm/view/recommendation/fetchEntityRecommendationsForLineUpdateEpic.js

@@ -0,0 +1,87 @@
+import { concat, of, timer } from 'rxjs';
+import { catchError, debounce, filter, groupBy, mergeMap, switchMap, } from 'rxjs/operators';
+import { getIsAccountingClassesEnabled } from '../../entity/tenant/tenantSelector';
+import { getTransactionWithCOT, getTransactionWithCOTFromRecommendations, } from '../../entity/transaction/transactionHelper';
+import { createZeniAPIStatus, isSuccessResponse } from '../../responsePayload';
+import { getUncategorizedAccounts } from '../accountList/accountListSelector';
+import { markCategoryClassRecommendationsCompletedForCategorization, markCategoryClassRecommendationsFailureForCategorization, markCategoryClassRecommendationsInProgressForCategorization, setEntityRecommendationForLineIdsForCategorization, } from '../expenseAutomationView/reducers/transactionsViewReducer';
+import { markCategoryClassRecommendationsCompletedForTransactionDetail, markCategoryClassRecommendationsFailureForTransactionDetail, markCategoryClassRecommendationsInProgressForTransactionDetail, setEntityRecommendationForLineIdsForTransactionDetail, } from '../transactionDetail/transactionDetailReducer';
+import { buildRecommendationUrl, getRecommendationByLineIdWithCOTFromRecommendationPayloadWithCOT, } from './recommendationHelper';
+import { fetchEntityRecommendationsForLineUpdate } from './recommendationReducer';
+// Close the per-target groupBy bucket after this much idle time so inactive
+// groups don't accumulate forever (each group holds a Subject + a chain of
+// active subscribers; without a duration selector groupBy retains them for
+// the lifetime of the source observable, which is the lifetime of the app).
+// Picked at 60s to leave a generous window for re-fetches on the same
+// payee/transaction/line target while still bounding memory.
+const GROUP_INACTIVITY_TIMEOUT_MS = 60000;
+// Build the groupBy key. Same flow + same transaction + same line set
+// share a target so switchMap can cancel an in-flight prior fetch. Use
+// NUL (\u0000) as separator because it can never appear in transaction
+// or line ids (vs the `|` used in an earlier WIP which collides with
+// pipe-delimited synthetic ids).
+const SEPARATOR = '\u0000';
+const toGroupKey = (flowType, transactionId, lineIds) => `${flowType}${SEPARATOR}${transactionId}${SEPARATOR}${[...lineIds]
+    .sort((a, b) => a.localeCompare(b))
+    .join(SEPARATOR)}`;
+// Targeted recommendations fetch that drives the per-line skeleton, the
+// list-page row-checkbox uncheck/recheck, and the page-level Save
+// disable.
+//
+// Concurrency model:
+//   - groupBy by (flowType, transactionId, sorted lineIds) so distinct
+//     targets run in parallel.
+//   - inside each group, switchMap so a re-fetch on the SAME target
+//     cancels any prior in-flight request for that target.
+//   - groupBy duration selector closes idle groups to bound memory.
+export const fetchEntityRecommendationsForLineUpdateEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchEntityRecommendationsForLineUpdate.match), groupBy((action) => toGroupKey(action.payload.flowType, action.payload.transactionDetails.transactionId.id, action.payload.transactionDetails.lineIds), undefined, (group$) => group$.pipe(debounce(() => timer(GROUP_INACTIVITY_TIMEOUT_MS)))), mergeMap((group$) => group$.pipe(switchMap((action) => {
+    const payload = action.payload;
+    const { transactionId, transaction, lineIds } = payload.transactionDetails;
+    const { entity, amount, isFetchCOT, isUncategorizedExpenseCategoryEnabled, } = payload;
+    // Synchronously emit the start arm so the per-line skeleton +
+    // row uncheck happen before the HTTP request begins. The
+    // discriminated-union payload narrows `payload.selectedTab` to
+    // a non-optional `TransactionsTab` inside the `'categorization'`
+    // branch, so no defensive fallthrough is needed.
+    const startAction = payload.flowType === 'categorization'
+        ? markCategoryClassRecommendationsInProgressForCategorization(payload.selectedTab, transactionId, lineIds)
+        : markCategoryClassRecommendationsInProgressForTransactionDetail(transactionId, lineIds);
+    const url = buildRecommendationUrl(zeniAPI.apiEndPoints.accountMicroServiceBaseUrl, entity, amount, payload.transactionDetails, isFetchCOT === true);
+    const httpStream$ = zeniAPI
+        .getJSON(url)
+        .pipe(mergeMap((response) => {
+        if (!isSuccessResponse(response) || response.data == null) {
+            return of(payload.flowType === 'categorization'
+                ? markCategoryClassRecommendationsFailureForCategorization(payload.selectedTab, transactionId, lineIds, response.status)
+                : markCategoryClassRecommendationsFailureForTransactionDetail(transactionId, lineIds, response.status));
+        }
+        const recommendationWithCOTByLineId = getRecommendationByLineIdWithCOTFromRecommendationPayloadWithCOT(response.data.recommendations, lineIds);
+        // HTTP 200 with no per-line recommendations: NOT an error.
+        // Flip lines to Completed so the skeleton resolves and
+        // downstream UI can treat this as "we tried, nothing to
+        // apply".
+        if (recommendationWithCOTByLineId == null) {
+            return of(payload.flowType === 'categorization'
+                ? markCategoryClassRecommendationsCompletedForCategorization(payload.selectedTab, transactionId, lineIds)
+                : markCategoryClassRecommendationsCompletedForTransactionDetail(transactionId, lineIds));
+        }
+        const transactionWithCOT = isFetchCOT === true
+            ? getTransactionWithCOTFromRecommendations(transaction, recommendationWithCOTByLineId)
+            : getTransactionWithCOT(transaction);
+        const uncategorizedIncomeExpense = getUncategorizedAccounts(state$.value.accountState, state$.value.accountListState, 'accountList');
+        if (payload.flowType === 'categorization') {
+            return of(setEntityRecommendationForLineIdsForCategorization(payload.selectedTab, transactionId, transactionWithCOT, lineIds, entity, amount, recommendationWithCOTByLineId, uncategorizedIncomeExpense, isUncategorizedExpenseCategoryEnabled, getIsAccountingClassesEnabled(state$.value)));
+        }
+        return of(setEntityRecommendationForLineIdsForTransactionDetail(transactionId, transactionWithCOT, lineIds, entity, amount, recommendationWithCOTByLineId, uncategorizedIncomeExpense));
+    }), catchError((error) => {
+        const errorMessage = 'fetchEntityRecommendationsForLineUpdate failed: ' +
+            (error instanceof Error
+                ? error.message
+                : JSON.stringify(error));
+        const status = createZeniAPIStatus('Unexpected Error', errorMessage);
+        return of(payload.flowType === 'categorization'
+            ? markCategoryClassRecommendationsFailureForCategorization(payload.selectedTab, transactionId, lineIds, status)
+            : markCategoryClassRecommendationsFailureForTransactionDetail(transactionId, lineIds, status));
+    }));
+    return concat(of(startAction), httpStream$);
+}))));

package/lib/esm/view/recommendation/recommendationHelper.js

@@ -1,4 +1,5 @@
 import { transformRecommendation, transformRecommendationWithCOT, } from '../../entity/transaction/payloadTypes/transactionPayload';
+import { getActualTransactionID } from '../transactionDetail/transactionDetailState';
 export const getRecommendationFromRecommendationPayload = (payload) => {
     if (payload == null || payload.length === 0) {
         return undefined;
@@ -37,6 +38,34 @@ export const getRecommendationWithCOTFromRecommendationPayloadWithCOT = (payload
     });
     return recommendations;
 };
+// Pluralized URL segment for entity types. Mirrors the legacy
+// fetchEntityRecommendationsByTransactionIdEpic.toEntityTypeURL.
+const toEntityTypeUrlSegment = (entityType) => `${entityType}s`;
+// Build the recommendations URL for a single entity + transaction target.
+// Centralizes the URL shape so the legacy
+// fetchEntityRecommendationsByTransactionIdEpic and the new
+// fetchEntityRecommendationsForLineUpdateEpic stay in lockstep.
+export const buildRecommendationUrl = (accountMicroServiceBaseUrl, entity, amount, transactionDetails, isFetchCOT) => {
+    const entityQuery = {
+        entity_name: entity.name,
+        entity_type: entity.type,
+    };
+    // Entity-id-null case: server expects entity_name / entity_type query
+    // instead of the {entityType}/{qboId}/recommendations path.
+    if (entity.qboId === entity.name) {
+        return `${accountMicroServiceBaseUrl}/1.0/recommendations?query=${encodeURIComponent(JSON.stringify(entityQuery))}`;
+    }
+    const query = {
+        amount,
+        transaction_id: getActualTransactionID(transactionDetails.transactionId.id),
+        transaction_type: transactionDetails.transaction.type,
+        line_ids: transactionDetails.lineIds,
+    };
+    if (isFetchCOT === true) {
+        query.include_cot = true;
+    }
+    return `${accountMicroServiceBaseUrl}/1.0/${toEntityTypeUrlSegment(entity.type)}/${entity.qboId}/recommendations?query=${encodeURIComponent(JSON.stringify(query))}`;
+};
 export const getRecommendationByLineIdWithCOTFromRecommendationPayloadWithCOT = (recommendationPayload, lineIds) => {
     if (recommendationPayload.length === 0) {
         return undefined;

package/lib/esm/view/recommendation/recommendationReducer.js

@@ -33,6 +33,31 @@ const recommendation = createSlice({
                 };
             },
         },
+        // Targeted recommendations fetch fired when the user changes the
+        // payee/customer on a single transaction line (or the JE sibling set
+        // for that change). Routed by `fetchEntityRecommendationsForLineUpdateEpic`
+        // which uses groupBy + switchMap to keep fetches for distinct targets
+        // running in parallel while same-target re-fetches still cancel each
+        // other. The flowType discriminator selects the categorization vs
+        // detail slice for the per-line In-Progress / Completed / Error state.
+        fetchEntityRecommendationsForLineUpdate: {
+            reducer(draft, action) {
+                const { entity } = action.payload;
+                const key = getEntityRecommendationKey(entity.type, entity.id);
+                // Unconditional flip to In-Progress; the previous variant only
+                // seeded when missing, which left stale fetchStates when a prior
+                // fetch had already populated the entity entry.
+                draft.recommendationByEntity[key] = {
+                    ...(draft.recommendationByEntity[key] ??
+                        initialEntityRecommendationState),
+                    fetchState: 'In-Progress',
+                    error: undefined,
+                };
+            },
+            prepare(args) {
+                return { payload: args };
+            },
+        },
         fetchRecommendationByEntityName: {
             reducer(draft, action) {
                 const { entityName, entityType } = action.payload;
@@ -111,7 +136,7 @@ const recommendation = createSlice({
         },
     },
 });
-export const { fetchEntityRecommendationsByTransactionId, fetchRecommendationByEntityName, fetchRecommendationByEntityId, updateRecommendationForEntity, updateRecommendationForEntityFailure, indicateReadyToInitializeRecommendation, clearRecommendation, } = recommendation.actions;
+export const { fetchEntityRecommendationsByTransactionId, fetchEntityRecommendationsForLineUpdate, fetchRecommendationByEntityName, fetchRecommendationByEntityId, updateRecommendationForEntity, updateRecommendationForEntityFailure, indicateReadyToInitializeRecommendation, clearRecommendation, } = recommendation.actions;
 export default recommendation.reducer;
 const doUpdateRecommendationForEntity = (draft, entityId, entityType, payload) => {
     const key = getEntityRecommendationKey(entityType, entityId);

package/lib/esm/view/transactionDetail/transactionDetailReducer.js

@@ -238,12 +238,34 @@ const transactionDetail = createSlice({
         saveTransactionDetailLocalData(draft, action) {
             const key = getTransactionDetailKey(action.payload.transactionId);
             const detail = recordGet(draft.transactionDetailById, key, undefined);
-            if (detail != null) {
-                draft.transactionDetailById[key] = {
-                    ...detail,
-                    transactionDetailLocalData: action.payload.transactionLocalData,
-                };
+            if (detail == null) {
+                return;
             }
+            const incoming = action.payload.transactionLocalData;
+            const prevById = detail.transactionDetailLocalData.lineItemById;
+            // Per-line `categoryClassRecommendationsFetchState` is owned by the
+            // recommendation epic/reducers (markInProgress / markCompleted /
+            // markFailure / setEntityRecommendationForLineIdsForTransactionDetail).
+            // Callers that rebuild `transactionLocalData` from a UI snapshot will
+            // typically have an out-of-date copy of this field (e.g. payee-change
+            // captures the snapshot before the epic's start arm runs and would
+            // otherwise clobber In-Progress back to undefined). Treat the field as
+            // sticky: only let the caller override it when they explicitly set it.
+            const mergedLineItemById = {};
+            Object.entries(incoming.lineItemById ?? {}).forEach(([lineId, line]) => {
+                mergedLineItemById[lineId] = {
+                    ...line,
+                    categoryClassRecommendationsFetchState: line.categoryClassRecommendationsFetchState ??
+                        prevById?.[lineId]?.categoryClassRecommendationsFetchState,
+                };
+            });
+            draft.transactionDetailById[key] = {
+                ...detail,
+                transactionDetailLocalData: {
+                    ...incoming,
+                    lineItemById: mergedLineItemById,
+                },
+            };
         },
         saveTransactionDetail(draft, action) {
             const key = getTransactionDetailKey(action.payload.transactionId);
@@ -365,6 +387,21 @@ const transactionDetail = createSlice({
                 const detail = recordGet(draft.transactionDetailById, key, undefined);
                 if (detail != null) {
                     const newLocalData = setEntityRecommendationForLineIdInLocalData(transaction, detail.transactionDetailLocalData, action.payload.entity, lineIds, uncategorizedIncomeExpense, recommendationWithCOTByLineId);
+                    // Release the per-line fetch flag for every line this fetch
+                    // covered so the inline skeleton resolves and the page-level
+                    // Save button can re-enable.
+                    lineIds.forEach((lineId) => {
+                        const lineItem = newLocalData.lineItemById[lineId];
+                        if (lineItem != null) {
+                            newLocalData.lineItemById[lineId] = {
+                                ...lineItem,
+                                categoryClassRecommendationsFetchState: {
+                                    fetchState: 'Completed',
+                                    error: undefined,
+                                },
+                            };
+                        }
+                    });
                     draft.transactionDetailById[key] = {
                         ...detail,
                         transactionDetailLocalData: newLocalData,
@@ -385,6 +422,84 @@ const transactionDetail = createSlice({
                 };
             },
         },
+        // Start arm of the line-update recommendations fetch for the detail
+        // page. Flips covered lines to In-Progress; detail page has no
+        // checkbox, so no auto-uncheck side effect.
+        markCategoryClassRecommendationsInProgressForTransactionDetail: {
+            reducer(draft, action) {
+                const { transactionId, lineIds } = action.payload;
+                const key = getTransactionDetailKey(transactionId);
+                const detail = recordGet(draft.transactionDetailById, key, undefined);
+                if (detail != null) {
+                    lineIds.forEach((lineId) => {
+                        const lineItem = detail.transactionDetailLocalData.lineItemById[lineId];
+                        if (lineItem != null) {
+                            detail.transactionDetailLocalData.lineItemById[lineId] = {
+                                ...lineItem,
+                                categoryClassRecommendationsFetchState: {
+                                    fetchState: 'In-Progress',
+                                    error: undefined,
+                                },
+                            };
+                        }
+                    });
+                }
+            },
+            prepare(transactionId, lineIds) {
+                return { payload: { transactionId, lineIds } };
+            },
+        },
+        // Completed arm. Used when the HTTP call succeeded but the server
+        // returned no per-line recommendations — still need to release the
+        // In-Progress flag.
+        markCategoryClassRecommendationsCompletedForTransactionDetail: {
+            reducer(draft, action) {
+                const { transactionId, lineIds } = action.payload;
+                const key = getTransactionDetailKey(transactionId);
+                const detail = recordGet(draft.transactionDetailById, key, undefined);
+                if (detail != null) {
+                    lineIds.forEach((lineId) => {
+                        const lineItem = detail.transactionDetailLocalData.lineItemById[lineId];
+                        if (lineItem != null) {
+                            detail.transactionDetailLocalData.lineItemById[lineId] = {
+                                ...lineItem,
+                                categoryClassRecommendationsFetchState: {
+                                    fetchState: 'Completed',
+                                    error: undefined,
+                                },
+                            };
+                        }
+                    });
+                }
+            },
+            prepare(transactionId, lineIds) {
+                return { payload: { transactionId, lineIds } };
+            },
+        },
+        markCategoryClassRecommendationsFailureForTransactionDetail: {
+            reducer(draft, action) {
+                const { transactionId, lineIds, error } = action.payload;
+                const key = getTransactionDetailKey(transactionId);
+                const detail = recordGet(draft.transactionDetailById, key, undefined);
+                if (detail != null) {
+                    lineIds.forEach((lineId) => {
+                        const lineItem = detail.transactionDetailLocalData.lineItemById[lineId];
+                        if (lineItem != null) {
+                            detail.transactionDetailLocalData.lineItemById[lineId] = {
+                                ...lineItem,
+                                categoryClassRecommendationsFetchState: {
+                                    fetchState: 'Error',
+                                    error,
+                                },
+                            };
+                        }
+                    });
+                }
+            },
+            prepare(transactionId, lineIds, error) {
+                return { payload: { transactionId, lineIds, error } };
+            },
+        },
         removeEntityRecommendationForLineIdForTransactionDetail: {
             reducer(draft, action) {
                 const { transaction, lineId } = action.payload;
@@ -656,7 +771,7 @@ const transactionDetail = createSlice({
         },
     },
 });
-export const { downloadAccountingProviderAttachment, downloadAccountingProviderAttachmentSuccess, downloadAccountingProviderAttachmentFailure, fetchTransactionDetail, updateTransactionDetailFetchState, removeTransactionDetail, clearTransactionDetail, uploadMissingAttachmentSuccess, updateTransactionDetail, updateTransactionDetailSaveStatus, clearTransactionDetailSaveStatus, markTransactionAsNotMiscategorized, deleteTransactionAttachment, deleteTransactionAttachmentFailure, deleteTransactionAttachmentSuccess, updateStatusForTransactionNotMiscategorizedUpdate, updateStatusConsolidatedSaveTransactionDetail, updateTransactionStateIfUpdateActionNotAllowed, saveTransactionDetail, initializeTransactionDetailLocalData, saveTransactionDetailLocalData, clearTransactionDetailLocalData, resetLineItemsCategoryClassInLocalData, setAllLineItemsToCategoryClassInLocalData, setAllLineItemsLocalDataIsUpdateAllChecked, setEntityRecommendationForLineIdsForTransactionDetail, removeEntityRecommendationForLineIdForTransactionDetail, updateSelectedVendor, updateSelectedCustomer, resetVendor, resetSelectedCustomer, updateLocalDataWithTransactionsUpdateWithVendorCheckbox, updateVendorToAllLineItems, resetAllLineItemsToVendor, updateLatestSelectedEntity, updateVendorBulkRecommendationsFetchStatus, setIsVendorUpdateAllChecked, } = transactionDetail.actions;
+export const { downloadAccountingProviderAttachment, downloadAccountingProviderAttachmentSuccess, downloadAccountingProviderAttachmentFailure, fetchTransactionDetail, updateTransactionDetailFetchState, removeTransactionDetail, clearTransactionDetail, uploadMissingAttachmentSuccess, updateTransactionDetail, updateTransactionDetailSaveStatus, clearTransactionDetailSaveStatus, markTransactionAsNotMiscategorized, deleteTransactionAttachment, deleteTransactionAttachmentFailure, deleteTransactionAttachmentSuccess, updateStatusForTransactionNotMiscategorizedUpdate, updateStatusConsolidatedSaveTransactionDetail, updateTransactionStateIfUpdateActionNotAllowed, saveTransactionDetail, initializeTransactionDetailLocalData, saveTransactionDetailLocalData, clearTransactionDetailLocalData, resetLineItemsCategoryClassInLocalData, setAllLineItemsToCategoryClassInLocalData, setAllLineItemsLocalDataIsUpdateAllChecked, setEntityRecommendationForLineIdsForTransactionDetail, markCategoryClassRecommendationsInProgressForTransactionDetail, markCategoryClassRecommendationsCompletedForTransactionDetail, markCategoryClassRecommendationsFailureForTransactionDetail, removeEntityRecommendationForLineIdForTransactionDetail, updateSelectedVendor, updateSelectedCustomer, resetVendor, resetSelectedCustomer, updateLocalDataWithTransactionsUpdateWithVendorCheckbox, updateVendorToAllLineItems, resetAllLineItemsToVendor, updateLatestSelectedEntity, updateVendorBulkRecommendationsFetchStatus, setIsVendorUpdateAllChecked, } = transactionDetail.actions;
 export default transactionDetail.reducer;
 function getUpdatedEntityLocalData(detail, updates, entity, resetRecommendations, type) {
     const key = type === 'customer' ? 'customerUpdates' : 'vendorUpdates';

package/lib/esm/view/transactionDetail/transactionDetailSelector.js

@@ -10,6 +10,26 @@ import { getAccountList, getNestedAccountListHierarchy, } from '../accountList/a
 import { getClassList, getNestedClassListHierarchy, } from '../classList/classListSelector';
 import { getProjectList, } from '../projectList/projectListSelector';
 import { getAllLinkedTransactions, getTransactionDetailKey, initialSupportedTransactionDetail, } from './transactionDetailState';
+// "Any line on this transaction is fetching category/class recommendations?"
+// Inlined as a plain function because the upstream selector
+// `getTransactionDetail` is also un-memoized and the iteration is O(lines)
+// — typically <10. Exported standalone so consumers that only need the
+// flag (e.g. footer save-disable) can avoid materializing the whole
+// detail report.
+export const getDetailInFlightRecommendations = (state, transactionId) => {
+    const detailKey = getTransactionDetailKey(transactionId);
+    const detail = recordGet(state.transactionDetailState.transactionDetailById, detailKey, undefined);
+    if (detail == null) {
+        return false;
+    }
+    for (const lineItem of Object.values(detail.transactionDetailLocalData.lineItemById)) {
+        if (lineItem.categoryClassRecommendationsFetchState?.fetchState ===
+            'In-Progress') {
+            return true;
+        }
+    }
+    return false;
+};
 export const getTransactionDetail = (state, transactionId, fetchLinkedTransactions = true) => {
     const { transactionDetailState, transactionState, vendorState, vendorListState, accountState, classState, classListState, accountListState, projectState, projectListState, } = state;
     const detailKey = getTransactionDetailKey(transactionId);
@@ -78,6 +98,7 @@ export const getTransactionDetail = (state, transactionId, fetchLinkedTransactio
         : [];
     const transactionDetailAnyUpdateStatus = reduceUpdateFetchStates(transactionDetail);
     const vendors = getVendorsByVendorIds(vendorState, vendorListState.vendorIds);
+    const hasInFlightCategoryClassRecommendations = getDetailInFlightRecommendations(state, transactionId);
     return {
         reportId: 'transaction_detail',
         reportTitle: 'Transaction Detail',
@@ -93,6 +114,7 @@ export const getTransactionDetail = (state, transactionId, fetchLinkedTransactio
         classHierarchyList,
         accountsHierarchyList,
         classList: classList,
+        hasInFlightCategoryClassRecommendations,
         isAccountingClassesEnabled,
         isAccountingProjectsEnabled,
         projectList,