@zeniai/client-epic-state 5.2.41-beta6MM → 5.2.41-beta8MM

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

@@ -102,32 +102,27 @@ const expenseAutomationReconciliationView = createSlice({
                         draft.selectedTab = 'review';
                         draft.selectedAccountId = action.payload.accountId;
                     }
-                    const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(action.payload.selectedPeriod)];
-                    const { transactionFetchState } = accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId];
-                    if (transactionFetchState.fetchState !== 'Completed' ||
+                    const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(action.payload.selectedPeriod)]?.reconciliationByAccountID[action.payload.accountId];
+                    if (accountRecon == null) {
+                        return;
+                    }
+                    if (accountRecon.transactionFetchState.fetchState !== 'Completed' ||
                         action.payload.cacheOverride === true) {
-                        const data = accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId];
                         if (action.payload.refreshViewInBackground === true) {
-                            accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId] = {
-                                ...data,
-                                refreshStatus: {
-                                    fetchState: 'In-Progress',
-                                    error: undefined,
-                                },
-                                accountId: action.payload.accountId,
-                                reconciliationId: undefined,
+                            accountRecon.refreshStatus = {
+                                fetchState: 'In-Progress',
+                                error: undefined,
                             };
+                            accountRecon.accountId = action.payload.accountId;
+                            accountRecon.reconciliationId = undefined;
                         }
                         else {
-                            accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId] = {
-                                ...data,
-                                transactionFetchState: {
-                                    fetchState: 'In-Progress',
-                                    error: undefined,
-                                },
-                                accountId: action.payload.accountId,
-                                reconciliationId: undefined,
+                            accountRecon.transactionFetchState = {
+                                fetchState: 'In-Progress',
+                                error: undefined,
                             };
+                            accountRecon.accountId = action.payload.accountId;
+                            accountRecon.reconciliationId = undefined;
                         }
                     }
                 }
@@ -179,14 +174,17 @@ const expenseAutomationReconciliationView = createSlice({
                 }
             }
             else {
-                const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(action.payload.selectedPeriod)];
+                const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(action.payload.selectedPeriod)]?.reconciliationByAccountID[action.payload.accountId];
+                if (accountRecon == null) {
+                    return;
+                }
                 if (action.payload.refreshViewInBackground === true) {
-                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].refreshStatus.error = action.payload.error;
-                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].refreshStatus.fetchState = 'Error';
+                    accountRecon.refreshStatus.error = action.payload.error;
+                    accountRecon.refreshStatus.fetchState = 'Error';
                 }
                 else {
-                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].transactionFetchState.error = action.payload.error;
-                    accountReconciliationRecords.reconciliationByAccountID[action.payload.accountId].transactionFetchState.fetchState = 'Error';
+                    accountRecon.transactionFetchState.error = action.payload.error;
+                    accountRecon.transactionFetchState.fetchState = 'Error';
                 }
             }
         },
@@ -391,8 +389,11 @@ const expenseAutomationReconciliationView = createSlice({
         },
         setStatementParseInProgress: (draft, action) => {
             const { accountId, selectedPeriod, statementParseInProgress } = action.payload;
-            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseInProgress =
-                statementParseInProgress;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon == null) {
+                return;
+            }
+            accountRecon.statementParseInProgress = statementParseInProgress;
         },
         setStatementProcessingDismissedToBackground: (draft, action) => {
             const { accountId, selectedPeriod, dismissedToBackground } = action.payload;
@@ -476,15 +477,23 @@ const expenseAutomationReconciliationView = createSlice({
         },
         uploadAccountStatementSuccess: (draft, action) => {
             const { accountId, selectedPeriod } = action.payload;
-            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementUploadStatus = {
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon == null) {
+                return;
+            }
+            accountRecon.statementUploadStatus = {
                 fetchState: 'Completed',
                 error: undefined,
             };
-            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementParseInProgress = true;
+            accountRecon.statementParseInProgress = true;
         },
         uploadAccountStatementFailure: (draft, action) => {
             const { accountId, selectedPeriod } = action.payload;
-            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementUploadStatus = {
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon == null) {
+                return;
+            }
+            accountRecon.statementUploadStatus = {
                 fetchState: 'Error',
                 error: action.payload.error,
             };
@@ -677,23 +686,34 @@ const expenseAutomationReconciliationView = createSlice({
         },
         reparseStatementFailure: (draft, action) => {
             const { accountId, selectedPeriod } = action.payload;
-            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].reparseStatementStatus = {
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon == null) {
+                return;
+            }
+            accountRecon.reparseStatementStatus = {
                 fetchState: 'Error',
                 error: action.payload.error,
             };
-            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].statementProcessingFailed = true;
+            accountRecon.statementProcessingFailed = true;
         },
         resetReparseStatementStatus: (draft, action) => {
             const { accountId, selectedPeriod } = action.payload;
-            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].reparseStatementStatus = {
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon == null) {
+                return;
+            }
+            accountRecon.reparseStatementStatus = {
                 fetchState: 'Not-Started',
                 error: undefined,
             };
         },
         updateParsedStatementData: (draft, action) => {
             const { accountId, selectedPeriod, parsedStatementData } = action.payload;
-            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].parsedStatementData =
-                parsedStatementData;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon == null) {
+                return;
+            }
+            accountRecon.parsedStatementData = parsedStatementData;
         },
         updateStatementUpdateLocalData: (draft, action) => {
             const { accountId, selectedPeriod, statementUpdateLocalData, statementUploadId, } = action.payload;
@@ -819,17 +839,21 @@ const expenseAutomationReconciliationView = createSlice({
         },
         updateAccountReconciliationLocalData: (draft, action) => {
             const { accountId, selectedPeriod, localData } = action.payload;
-            const oldLocalData = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].localData;
+            const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+            if (accountRecon == null) {
+                return;
+            }
+            const oldLocalData = accountRecon.localData;
             if (oldLocalData == null) {
-                draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].localData = localData;
+                accountRecon.localData = localData;
             }
             else {
-                draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].localData = {
+                accountRecon.localData = {
                     ...oldLocalData,
                     ...localData,
                 };
             }
-            draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId].localData = {
+            accountRecon.localData = {
                 ...oldLocalData,
                 ...localData,
             };
@@ -1119,7 +1143,10 @@ function updateAllReconciliation(draft, accounts, selectedPeriod, reconciliation
     }
 }
 function updateReconciliationByAccountID(draft, accounts, selectedPeriod, accountId, reconciliationData, refreshViewInBackground) {
-    const oldRecord = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId];
+    const accountRecon = draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)]?.reconciliationByAccountID[accountId];
+    if (accountRecon == null) {
+        return;
+    }
     const oldConnectionStatus = draft.accountConnectionStatusByAccountID[accountId];
     draft.accountConnectionStatusByAccountID[accountId] = {
         status: toBankStatusCodeType(reconciliationData.bank_status.code),
@@ -1129,21 +1156,17 @@ function updateReconciliationByAccountID(draft, accounts, selectedPeriod, accoun
             : false,
         paymentAccountId: accounts.payment_account_id ?? undefined,
     };
-    const statementParseInProgress = resolveStatementParseInProgressAfterFetch(oldRecord, reconciliationData);
+    const statementParseInProgress = resolveStatementParseInProgressAfterFetch(accountRecon, reconciliationData);
+    accountRecon.reconciliationId =
+        reconciliationData.reconciliation_id ?? undefined;
+    accountRecon.statementParseInProgress = statementParseInProgress;
     if (refreshViewInBackground === true) {
-        draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId] = {
-            ...oldRecord,
-            reconciliationId: reconciliationData.reconciliation_id ?? undefined,
-            refreshStatus: { fetchState: 'Completed', error: undefined },
-            statementParseInProgress,
-        };
+        accountRecon.refreshStatus = { fetchState: 'Completed', error: undefined };
     }
     else {
-        draft.accountReconciliationRecordsBySelectedPeriod[toMonthYearPeriodId(selectedPeriod)].reconciliationByAccountID[accountId] = {
-            ...oldRecord,
-            statementParseInProgress,
-            reconciliationId: reconciliationData.reconciliation_id ?? undefined,
-            transactionFetchState: { fetchState: 'Completed', error: undefined },
+        accountRecon.transactionFetchState = {
+            fetchState: 'Completed',
+            error: undefined,
         };
     }
 }
@@ -1173,7 +1196,11 @@ const updateExcludedAccountExclusionInfo = (draft, account) => {
     };
 };
 const updateReconciliationByAccountIDOnIncludeAccount = (draft, accountId, reconciliation, monthYearPeriodId) => {
-    draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId].reconciliationByAccountID[accountId] = {
+    const accountReconciliationRecords = draft.accountReconciliationRecordsBySelectedPeriod[monthYearPeriodId];
+    if (accountReconciliationRecords == null) {
+        return;
+    }
+    accountReconciliationRecords.reconciliationByAccountID[accountId] = {
         accountId,
         reconciliationId: reconciliation.reconciliation_id ?? undefined,
         transactionFetchState: { fetchState: 'Not-Started', error: undefined },

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

@@ -373,6 +373,16 @@ const expenseAutomationTransactionsView = createSlice({
                 if (cached != null) {
                     autoCat.uiState.pageToken = cached.pageToken;
                     autoCat.uiState.totalCount = { ...cached.totalCount };
+                    // Keep the stored badge in step with the restored sub-tab: the selector
+                    // falls back to it for any period this sub-tab has not loaded. Merged,
+                    // not replaced -- the snapshot only holds periods this sub-tab actually
+                    // loaded, while the badge map also carries periods filled from a Review
+                    // response's `other_tab_total_count`. Overwriting would drop those and
+                    // leave the badge at 0 for any period this sub-tab never visited.
+                    draft.parentTotalCountByTab.autoCategorized = {
+                        ...draft.parentTotalCountByTab.autoCategorized,
+                        ...cached.totalCount,
+                    };
                     autoCat.uiState.scrollPosition = cached.scrollPosition;
                     autoCat.transactionIdsBySelectedPeriod = {
                         ...cached.transactionIdsBySelectedPeriod,

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

@@ -333,6 +333,7 @@ function toActualMatchingMatchView(match) {
             : match.leftovers.map(toMatchModalAccrual),
     };
 }
+const EMPTY_ACTUAL_MATCHING_ROWS = [];
 export function getExpenseAutomationActualMatchingMatchView(state, matchId) {
     const view = state.expenseAutomationActualMatchingViewState;
     const match = getActualMatchingMatchById(state.actualMatchingState, matchId);
@@ -353,6 +354,9 @@ export function getCloseMatchAfterIgnoreMatchId(state) {
     return state.expenseAutomationActualMatchingViewState
         .closeMatchAfterIgnoreMatchId;
 }
+export function getActualMatchingMatchModalConfirmStatus(state) {
+    return state.expenseAutomationActualMatchingViewState.matchModal.confirmStatus;
+}
 export function getExpenseAutomationActualMatchingView(state) {
     const { expenseAutomationActualMatchingViewState } = state;
     const { matchIdsByPeriod, fetchState, error, refreshStatus, uiState, matchModal, ignoreStatusByMatchId, undoReversalStatusByMatchId, } = expenseAutomationActualMatchingViewState;
@@ -369,10 +373,10 @@ export function getExpenseAutomationActualMatchingView(state) {
     const includeReversed = uiState.statusFilter !== 'pending_review';
     const reversed = includeReversed
         ? sortActualMatchingRows(rows.filter((row) => isReversedMatchKind(row.kind)), uiState)
-        : [];
+        : EMPTY_ACTUAL_MATCHING_ROWS;
     const pendingReview = includePendingReview
         ? sortActualMatchingRows(rows.filter((row) => row.kind === 'pending_review'), uiState)
-        : [];
+        : EMPTY_ACTUAL_MATCHING_ROWS;
     const kpiSummary = buildActualMatchingKpiSummary(allRows, getTenantDisplayCurrency(state)?.currencyCode);
     const searchedAccruals = matchModal.accrualSearch.results
         .map((key) => getJEOneTimeAccrualByKey(key, state.jeSchedulesState))

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

@@ -210,7 +210,7 @@ export function getExpenseAutomationJESchedulesView(state) {
     const accruedSchedules = [];
     const oneTimeAccruals = [];
     const { accountState, accountListState, classState, classListState, expenseAutomationJESchedulesViewState, expenseAutomationViewState, monthEndCloseChecksState, } = state;
-    const { jeScheduleTransactionKeysByPeriodAndTab, jeScheduleAccruedKeysByPeriodAndTab, jeScheduleOneTimeAccrualKeysByPeriodAndTab, failedJeScheduleTransactionKeysByPeriodAndTab, jeScheduleLocalDataById, postStatusById, ignoreStatusById, revertStatusById, oneTimeAccrualActionStatusById, uiState, error, fetchState, refreshStatus, newSchedule, } = expenseAutomationJESchedulesViewState;
+    const { jeScheduleTransactionKeysByPeriodAndTab, jeScheduleAccruedKeysByPeriodAndTab, jeScheduleOneTimeAccrualKeysByPeriodAndTab, failedJePostings, jeScheduleLocalDataById, postStatusById, ignoreStatusById, revertStatusById, oneTimeAccrualActionStatusById, uiState, error, fetchState, refreshStatus, newSchedule, } = expenseAutomationJESchedulesViewState;
     const accountSettingsView = getJEAccountSettingsView(state);
     const newScheduleView = newSchedule.selectedDetailScheduleType === 'fixed_assets' ||
         newSchedule.selectedDetailScheduleType === 'prepaid_expenses'
@@ -249,15 +249,11 @@ export function getExpenseAutomationJESchedulesView(state) {
     const jeScheduleTransactionKeysForSelectedTab = selectedPeriodTabKey != null
         ? jeScheduleTransactionKeysByPeriodAndTab[selectedPeriodTabKey]
         : undefined;
-    const failedJeScheduleTransactionKeysForSelectedTab = selectedPeriodTabKey != null
-        ? failedJeScheduleTransactionKeysByPeriodAndTab[selectedPeriodTabKey]
-        : undefined;
     // Distinguishes "this tab has never been fetched for this period" from "fetched and genuinely
     // empty". Without it the page cannot tell a first visit from a real empty state, and renders an
     // empty table where it should render a skeleton.
     const hasLoadedForSelectedTab = jeScheduleTransactionKeysForSelectedTab != null;
     const jeScheduleTransactionKeys = jeScheduleTransactionKeysForSelectedTab ?? [];
-    const failedJeScheduleTransactionKeys = failedJeScheduleTransactionKeysForSelectedTab ?? [];
     const jeScheduleAccruedKeys = (selectedPeriodTabKey != null
         ? jeScheduleAccruedKeysByPeriodAndTab[selectedPeriodTabKey]
         : undefined) ?? [];
@@ -280,24 +276,57 @@ export function getExpenseAutomationJESchedulesView(state) {
             accruedSchedules.push(accruedScheduleDetails);
         }
     });
-    failedJeScheduleTransactionKeys.forEach((jeScheduleKey) => {
-        const jeScheduleDetails = getJEScheduledTransactionByJEScheduleTransactionKey(jeScheduleKey, state);
-        failedJeScheduledTransaction.push(jeScheduleDetails);
+    // Sourced from the tenant-wide bucket, not the per-period one: a failed posting belongs to no
+    // close month, and windowing it is what kept older failures off the only tab that can resolve
+    // them.
+    failedJePostings.jeScheduleTransactionKeys.forEach((jeScheduleKey) => {
+        // getJEScheduledTransactionByJEScheduleTransactionKey throws three different ways: it
+        // destructures the result of recordGet without a null check, and it raises explicitly for a
+        // missing vendor and for a missing base transaction. Catching rather than pre-checking each
+        // one keeps this correct if a fourth is added, and none of the three is recoverable here --
+        // the row cannot be drawn either way.
+        //
+        // This matters more for this bucket than anywhere else on the page. It is tenant-wide, so it
+        // names schedules the close-month list never loaded, and the group is defined by deleted
+        // vendors and deleted categories -- precisely the rows whose entities are most likely to be
+        // missing. Unguarded, one such key takes down the whole JE tab instead of dropping one row.
+        try {
+            failedJeScheduledTransaction.push(getJEScheduledTransactionByJEScheduleTransactionKey(jeScheduleKey, state));
+        }
+        catch {
+            // Intentionally swallowed: a failed posting we cannot resolve is one missing row, and the
+            // alternative is a blank page for every other row too.
+        }
     });
+    // What the endpoint last reported as failing. The entity store keeps every month a schedule
+    // has and an entry resolved by someone else keeps its old `error` array, so `error` alone would
+    // leave a Retry button on a posting that is no longer failing.
+    const failedScheduledJournalEntryIDs = new Set(failedJePostings.scheduledJournalEntryIDs);
     const { sortKey, sortOrder, selectedJETypeFilter } = uiState;
+    const matchesTypeFilter = (schedule) => selectedJETypeFilter == null ||
+        getJEScheduleRowType(schedule) === selectedJETypeFilter;
     const unsortedResolveSchedules = [];
     failedJeScheduledTransaction.forEach((schedule) => {
-        schedule.scheduledJournalEntry.forEach((journalEntry) => {
+        // Only the entries that actually carry an error. The schedule's entry array is shared state:
+        // opening a schedule's detail page or Quick View replaces it with every month the schedule
+        // has, posted ones included, so fanning out over all of them turned one failed posting into a
+        // row per month -- and a month that never failed has nothing to resolve, so it rendered with
+        // an empty action column.
+        //
+        // Intersected with the ids the endpoint actually returned, not just `error`: the entry array
+        // is a cache of every month, and an entry whose failure someone else resolved keeps its stale
+        // error array until something overwrites it. Only what the last fetch named is still failing.
+        schedule.scheduledJournalEntry
+            .filter((journalEntry) => journalEntry.error.length > 0 &&
+            failedScheduledJournalEntryIDs.has(journalEntry.scheduledJournalEntryID))
+            .forEach((journalEntry) => {
             unsortedResolveSchedules.push({
                 ...schedule,
                 scheduledJournalEntry: journalEntry,
             });
         });
     });
-    const resolveSchedules = sortJEScheduledTransactions(unsortedResolveSchedules, sortKey, sortOrder);
-    const validResolveForPending = unsortedResolveSchedules.filter((r) => jeScheduleLocalDataById[r.scheduledJournalEntry.scheduledJournalEntryID] != null);
-    const matchesTypeFilter = (schedule) => selectedJETypeFilter == null ||
-        getJEScheduleRowType(schedule) === selectedJETypeFilter;
+    const resolveSchedules = sortJEScheduledTransactions(unsortedResolveSchedules.filter(matchesTypeFilter), sortKey, sortOrder);
     const isCreatedStatus = (schedule) => {
         // An accrual is "created" once it is not review work: posted, reversing, reversed, or in a
         // transient posting claim.
@@ -315,7 +344,6 @@ export function getExpenseAutomationJESchedulesView(state) {
     ];
     const pendingReviewSchedules = sortJEScheduledTransactions([
         ...allScheduleRows.filter((schedule) => isPendingReviewRow(schedule) && matchesTypeFilter(schedule)),
-        ...validResolveForPending,
     ], sortKey, sortOrder);
     const createdSchedules = sortJEScheduledTransactions(allScheduleRows.filter((schedule) => isCreatedStatus(schedule) && matchesTypeFilter(schedule)), sortKey, sortOrder);
     // KPI summary — derived from unfiltered schedules so counts are always accurate
@@ -434,6 +462,13 @@ export function getExpenseAutomationJESchedulesView(state) {
         kpiSummary,
         pendingReviewSchedules,
         pendingReviewTotal,
+        failedPostings: resolveSchedules,
+        // Exposed so a consumer can tell "still loading" and "the lookup failed" from "nothing has
+        // failed". The bucket keeps its rows on failure precisely so an error can be shown beside
+        // them, which is only possible if the state travels with them.
+        failedPostingsFetchState: failedJePostings.fetchState,
+        // Deprecated alias of failedPostings. Still read by the section's footer-form effect and by
+        // app-ui analytics; remove once both are repointed.
         resolveSchedules: resolveSchedules,
         accountSettingsView,
         newScheduleView,

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

@@ -1,6 +1,6 @@
 import { createSelector } from '@reduxjs/toolkit';
 import omit from 'lodash/omit';
-import { toMonthYearPeriodId } from '../../../commonStateTypes/timePeriod';
+import { toMonthYearPeriodId, } from '../../../commonStateTypes/timePeriod';
 import { getCurrentTenant, getIsAccountingProjectsEnabled, } from '../../../entity/tenant/tenantSelector';
 import { getTransactionWithCOT } from '../../../entity/transaction/transactionHelper';
 import { getSupportedTransactionsByIds } from '../../../entity/transaction/transactionSelector';
@@ -172,18 +172,35 @@ export function getExpenseAutomationTransactionView(state) {
         review: monthYearPeriodId != null ? totalCountByReview[monthYearPeriodId] : 0,
         autoCategorized: monthYearPeriodId != null ? totalCountByAutoCat[monthYearPeriodId] : 0,
     };
-    // Parent-tab badge counts. Sourced from `parent_tab_total_count` in the
-    // listing response and used exclusively by the navbar / tab strip badges.
-    // Independent of which Completed sub-tab is active so the badge stays
-    // stable across sub-tab switches.
+    // Tab badge counts, used exclusively by the navbar / tab strip badges. Both
+    // tabs are counted under the filters applied to the list, so a badge always
+    // equals the number of rows that tab shows.
+    //
+    // The ACTIVE tab prefers its own list count: the two are the same number (the
+    // backend's parent_tab_total_count mirrors total_count), but `uiState.totalCount`
+    // is restored by every cache path that skips a fetch -- switching back to an
+    // already-loaded period, or to a cached Completed sub-tab -- whereas the stored
+    // badge is only written when a response lands, so on those paths it would keep
+    // showing whatever was fetched last.
+    //
+    // The `in` check is load-bearing, not defensive: `totalCount` is a per-period
+    // map typed as `Record<MonthYearPeriodId, number>`, so indexing it is typed
+    // `number` but is `undefined` for any period the active (sub-)tab has not
+    // loaded -- the window between switching to a fresh sub-tab and its response
+    // landing. Falling back to the stored badge there keeps a real number in the
+    // label instead of blanking it.
     const parentTotalCountByTab = expenseAutomationTransactionsViewState.parentTotalCountByTab;
+    const storedBadgeByTab = (tab) => monthYearPeriodId != null
+        ? (parentTotalCountByTab[tab][monthYearPeriodId] ?? 0)
+        : 0;
+    const badgeForTab = (tab, listCountByPeriod) => selectedTransactionCategorizationTab === tab &&
+        monthYearPeriodId != null &&
+        monthYearPeriodId in listCountByPeriod
+        ? listCountByPeriod[monthYearPeriodId]
+        : storedBadgeByTab(tab);
     const parentTabTotalCountByTab = {
-        review: monthYearPeriodId != null
-            ? (parentTotalCountByTab.review[monthYearPeriodId] ?? 0)
-            : 0,
-        autoCategorized: monthYearPeriodId != null
-            ? (parentTotalCountByTab.autoCategorized[monthYearPeriodId] ?? 0)
-            : 0,
+        review: badgeForTab('review', totalCountByReview),
+        autoCategorized: badgeForTab('autoCategorized', totalCountByAutoCat),
     };
     const fetchStateByTab = {
         review: {

package/lib/esm/view/invoicing/createInvoice/createInvoiceSelector.js

@@ -1,8 +1,35 @@
 import { getAddressByAddressId } from '../../../entity/address/addressSelector';
+import { invoicingPricePointDisplayAmount } from '../../../entity/invoicing/plan/planSelector';
 import { getInvoicingCatalogListView, getInvoicingCatalogPrices, } from '../invoicingCatalogListView/invoicingCatalogListViewSelector';
 import { invoicingFieldHelpForGroup } from '../invoicingConfigView/invoicingConfigViewSelector';
 import { getInvoicingCustomerListView } from '../invoicingCustomerListView/invoicingCustomerListViewSelector';
 import { getInvoicingSettings } from '../settingsView/settingsViewSelector';
+/**
+ * Pricing models whose single-unit amount is a true per-unit rate — the only
+ * ones a Create Invoice line may be prefilled from. Typed against the entity
+ * union so a misspelt member fails to compile; a model added to the union
+ * still has to be classified here by hand (it is left out, so it fails closed:
+ * no prefill). The complement is `isTieredCatalogPricingModel`.
+ */
+const PER_UNIT_RATE_PRICING_MODELS = [
+    'per_unit',
+    'flat_fee',
+];
+/**
+ * Whether a price point's single-unit amount is a per-unit rate. A missing
+ * model means per-unit: the service defaults `pricing_model` to `per_unit`
+ * and older records may omit it.
+ */
+const hasPerUnitRate = (pricingModel) => pricingModel == null ||
+    pricingModel === '' ||
+    PER_UNIT_RATE_PRICING_MODELS.some((model) => model === pricingModel);
+/**
+ * The amount to prefill on a Create Invoice line for a price point, or
+ * `undefined` when there is no safe per-unit rate to prefill.
+ */
+const planNamePrefillPrice = (pricePoint) => hasPerUnitRate(pricePoint.pricingModel)
+    ? invoicingPricePointDisplayAmount(pricePoint)?.amount
+    : undefined;
 /**
  * Display name for a customer option: company, else the full name, else the
  * email, else the raw id.
@@ -47,7 +74,7 @@ export const getCreateInvoiceFormView = (state) => {
             .filter((subFamily) => (subFamily.name ?? '') !== '')
             .map((subFamily) => ({
             planName: plan.name ?? '',
-            price: subFamily.price?.amount,
+            price: planNamePrefillPrice(subFamily),
             subFamilyName: subFamily.name ?? '',
         }))),
         products: getInvoicingCatalogPrices(catalogListView.products),

package/lib/esm/view/invoicing/editInvoicingCatalogItemDetailView/editInvoicingCatalogItemDetailViewPayload.js

@@ -3,7 +3,6 @@ import { toClassBasePayload } from '../../../entity/class/classPayload';
 import { blankInvoicingCatalogSubFamily, isTieredCatalogPricingModel, } from './invoicingCatalogItemFormHelper';
 const CURRENCY_CODE = 'USD';
 const trimOrUndefined = (value) => value.trim() !== '' ? value.trim() : undefined;
-const trimOrNull = (value) => value.trim() !== '' ? value.trim() : null;
 const toProductCode = (value) => value
     .trim()
     .toLowerCase()
@@ -91,13 +90,24 @@ const buildSubFamilyPayload = (localData, subFamily, clearEmptyValues, lookup) =
 /** `unit` is the item's unit of measure, not a currency; `CURRENCY_CODE` above prices Price points. */
 const DEFAULT_CATALOG_ITEM_UNIT = 'USD';
 /**
- * Build the parent catalog-item request body from the form draft. Creates omit
- * both parent and price point IDs; edits retain returned price point IDs.
+ * Build the parent catalog-item request body from the form draft. Every field
+ * the form holds is sent, so a value cleared on the form is cleared on the
+ * item: the service reads an absent key as "leave it alone", which is why
+ * `description` travels as an empty string and `applicable_items` as an empty
+ * list rather than being dropped. Fields the form does not collect
+ * (`external_name`, `item_family_id`, `metadata`, …) stay off the body so an
+ * edit cannot overwrite them with a value nobody chose.
  */
 export const localDataToSaveInvoicingCatalogItemPayload = (localData, isCreate, lookup) => {
-    const description = trimOrUndefined(localData.description);
     const productCode = trimOrUndefined(localData.productCode) ?? toProductCode(localData.name);
     const itemPayload = {
+        // `applicable_items` only means anything while the item is restricted;
+        // sending the empty list otherwise is what clears a restriction that was
+        // just lifted.
+        applicable_items: localData.itemApplicability === 'restricted'
+            ? localData.applicableItems
+            : [],
+        description: trimOrUndefined(localData.description) ?? '',
         enabled_for_checkout: true,
         enabled_in_portal: true,
         is_giftable: false,
@@ -107,41 +117,63 @@ export const localDataToSaveInvoicingCatalogItemPayload = (localData, isCreate,
         name: localData.name.trim(),
         product_code: productCode,
         type: localData.catalogType,
+        // The form no longer collects a unit; an item that already has one keeps it.
+        unit: trimOrUndefined(localData.unit) ?? DEFAULT_CATALOG_ITEM_UNIT,
     };
-    if (description != null) {
-        itemPayload.description = description;
-    }
-    // The form no longer collects a unit; an item that already has one keeps it.
-    itemPayload.unit =
-        trimOrUndefined(localData.unit) ?? DEFAULT_CATALOG_ITEM_UNIT;
-    if (localData.itemApplicability === 'restricted' &&
-        localData.applicableItems.length > 0) {
-        itemPayload.applicable_items = localData.applicableItems;
+    // The external id is assigned by the billing service and shown read-only, so
+    // it is echoed back only when the item already has one: sending the blank a
+    // create starts with would clear an id assigned in the meantime.
+    const externalId = trimOrUndefined(localData.externalId);
+    if (externalId != null) {
+        itemPayload.external_id = externalId;
     }
     const subFamilies = localData.subFamilies.length > 0
         ? localData.subFamilies
         : [blankInvoicingCatalogSubFamily()];
-    itemPayload.sub_family_details = isCreate
-        ? subFamilies.map((subFamily) => buildSubFamilyPayload(localData, subFamily, false, lookup))
-        : subFamilies.map((subFamily) => {
-            const priceCode = trimOrUndefined(subFamily.priceCode) ?? toProductCode(subFamily.name);
-            const detail = {
-                description: trimOrNull(subFamily.description),
-                invoice_notes: trimOrNull(subFamily.invoiceNotes),
-                name: subFamily.name.trim(),
-                price_code: priceCode,
-                show_description_in_invoices: subFamily.showDescriptionInInvoices,
-            };
-            // Edits send a narrower body than creates, but the accounting mapping
-            // is editable on this form, so leaving it out dropped the account and
-            // class the user had just picked. `null` rather than omitted when it is
-            // empty: an absent key on an update reads as "leave it alone", which
-            // would make a cleared mapping impossible to save — the same reason
-            // `description` and `invoice_notes` go through `trimOrNull`.
-            detail.accounting_detail =
-                buildAccountingDetail(subFamily, lookup) ?? null;
-            const id = trimOrUndefined(subFamily.id);
-            return id != null ? { ...detail, id } : detail;
-        });
+    if (isCreate) {
+        itemPayload.sub_families = subFamilies.map((subFamily) => buildSubFamilyPayload(localData, subFamily, false, lookup));
+        return itemPayload;
+    }
+    // Only price points the service has already stored travel in an update: it
+    // addresses them by id, and a blank one has nothing to address. A price point
+    // added on the form is created by its own request once the item is saved,
+    // rather than riding along as a row the update cannot place.
+    itemPayload.sub_families = subFamilies
+        .filter((subFamily) => subFamily.id !== '')
+        .map((subFamily) => {
+        // Edits send the same body a create does. The narrower hand-built one
+        // this replaces had to be kept in step by hand and was not: it dropped
+        // `accounting_detail` once, and `billing_cycles`, `price`,
+        // `pricing_model`, `period`, the trial fields, `proration_type`,
+        // `free_quantity`, `is_taxable` and `tiers` were never added at all, so
+        // editing any of them looked saved and changed nothing.
+        const detail = buildSubFamilyPayload(localData, subFamily, true, lookup);
+        // `null` rather than omitted when empty: an absent key on an update
+        // reads as "leave it alone", which would make a cleared mapping
+        // impossible to save — the same reason `description` and
+        // `invoice_notes` are cleared rather than dropped above.
+        detail.accounting_detail = detail.accounting_detail ?? null;
+        // Never blank: the filter above leaves only price points the service has
+        // already stored, which is the only kind an update can address.
+        return { ...detail, id: subFamily.id };
+    });
     return itemPayload;
 };
+/**
+ * The bodies that create the price points added on an edit form, one per
+ * request to `/catalog/products`.
+ *
+ * An update cannot carry them: it addresses price points by id, and these have
+ * none until the service assigns one. They are bound to their item by
+ * `item_id`, so this needs the saved item's id and runs after the item itself
+ * is saved.
+ *
+ * Empty values are left off rather than sent as `null`: there is nothing on a
+ * price point that does not exist yet to clear.
+ */
+export const localDataToCreateInvoicingCatalogProductPayloads = (localData, itemId, lookup) => localData.subFamilies
+    .filter((subFamily) => subFamily.id === '')
+    .map((subFamily) => ({
+    ...buildSubFamilyPayload(localData, subFamily, false, lookup),
+    item_id: itemId,
+}));