@zeniai/client-epic-state 5.1.0-betaSS3 → 5.1.1-beta0ND

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,136 @@
+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,
+    };
+    // The server contract for `transaction-type-update` expects
+    // `transaction_memo`, but the client-side action payload field is named
+    // `memo` (callers in web-components dispatch with `memo`). The names are
+    // intentionally kept separate: `memo` is the internal client model and
+    // `transaction_memo` is the wire format. Don't unify them without
+    // updating the action contract and all dispatchers in lockstep.
+    const payload = {
+        transaction_type: transactionType,
+        transaction_id: transactionId,
+        to_account_integration_id: creditAccountIntegrationId,
+        from_account_integration_id: debitAccountIntegrationId,
+        transaction_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/dashboard/dashboardReducer.js

@@ -1,8 +1,9 @@
 import { createSlice } from '@reduxjs/toolkit';
 import { dateNow } from '../../zeniDayJS';
+import { updateTreasuryPromoIntroClosedByOutsideClick, updateTreasuryPromoRemindMeLaterClicked, } from '../spendManagement/treasury/treasurySetUp/treasurySetupViewReducer';
 export const initialState = {
-    lastFetchRequestTime: undefined,
     isTreasuryVideoClosed: false,
+    lastFetchRequestTime: undefined,
 };
 const dashboard = createSlice({
     name: 'dashboard',
@@ -32,6 +33,15 @@ const dashboard = createSlice({
             Object.assign(draft, initialState);
         },
     },
+    extraReducers: (builder) => {
+        builder
+            .addCase(updateTreasuryPromoRemindMeLaterClicked, (draft) => {
+            draft.isTreasuryVideoClosed = true;
+        })
+            .addCase(updateTreasuryPromoIntroClosedByOutsideClick, (draft) => {
+            draft.isTreasuryVideoClosed = true;
+        });
+    },
 });
 export const { fetchDashboard, updateTreasuryVideoClosed, clearDashboard } = dashboard.actions;
 export default dashboard.reducer;

package/lib/esm/view/expenseAutomationView/epics/common/fetchAllExpenseAutomationTabsEpic.js

@@ -9,7 +9,7 @@ import { fetchMissingReceipts } from '../../reducers/missingReceiptsViewReducer'
 import { fetchReconciliation } from '../../reducers/reconciliationViewReducer';
 import { fetchTransactionCategorizationView } from '../../reducers/transactionsViewReducer';
 export const fetchAllExpenseAutomationTabsEpic = (actions$, state$) => actions$.pipe(filter(fetchAllExpenseAutomationTabs.match), switchMap((action) => {
-    const { cacheOverride, refreshViewInBackground, isUncategorizedExpenseCategoryEnabled, statuses, countOnlyStatuses, } = action.payload;
+    const { cacheOverride, refreshViewInBackground, isUncategorizedExpenseCategoryEnabled, } = action.payload;
     const state = state$.value;
     const { monthEndCloseChecksState } = state;
     const { monthEndCloseChecksByTenantId } = monthEndCloseChecksState;
@@ -30,7 +30,7 @@ export const fetchAllExpenseAutomationTabsEpic = (actions$, state$) => actions$.
     }
     if (cacheOverride === true) {
         const actions = [];
-        actions.push(fetchTransactionCategorizationView(selectedTransactionCategorizationTab, { start: timePeriodStart, end: timePeriodEnd }, cacheOverride, false, undefined, undefined, refreshViewInBackground, false, isUncategorizedExpenseCategoryEnabled, statuses, countOnlyStatuses), fetchMissingReceipts({ start: timePeriodStart, end: timePeriodEnd }, {
+        actions.push(fetchTransactionCategorizationView(selectedTransactionCategorizationTab, { start: timePeriodStart, end: timePeriodEnd }, cacheOverride, false, undefined, undefined, refreshViewInBackground, false, isUncategorizedExpenseCategoryEnabled), fetchMissingReceipts({ start: timePeriodStart, end: timePeriodEnd }, {
             amount: 75.0,
             currencyCode: 'USD',
             currencySymbol: '$',
@@ -83,7 +83,7 @@ export const fetchAllExpenseAutomationTabsEpic = (actions$, state$) => actions$.
             (state.expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTransactionCategorizationTab].hasValidState() === false ||
                 state.expenseAutomationTransactionsViewState
                     .transactionCategorizationView[selectedTransactionCategorizationTab].transactionIdsBySelectedPeriod[monthYearPeriodId] == null)) {
-            fetchActions.push(fetchTransactionCategorizationView(selectedTransactionCategorizationTab, { start: timePeriodStart, end: timePeriodEnd }, cacheOverride, false, undefined, undefined, refreshViewInBackground, false, isUncategorizedExpenseCategoryEnabled, statuses, countOnlyStatuses));
+            fetchActions.push(fetchTransactionCategorizationView(selectedTransactionCategorizationTab, { start: timePeriodStart, end: timePeriodEnd }, cacheOverride, false, undefined, undefined, refreshViewInBackground, false, isUncategorizedExpenseCategoryEnabled));
         }
         return from(fetchActions);
     }

package/lib/esm/view/expenseAutomationView/epics/common/refreshExpenseAutomationCurrentTabEpic.js

@@ -10,7 +10,7 @@ import { fetchMissingReceipts } from '../../reducers/missingReceiptsViewReducer'
 import { fetchReconciliation } from '../../reducers/reconciliationViewReducer';
 import { fetchTransactionCategorizationView } from '../../reducers/transactionsViewReducer';
 export const refreshExpenseAutomationCurrentTabEpic = (actions$, state$) => actions$.pipe(filter(refreshExpenseAutomationCurrentTab.match), switchMap((action) => {
-    const { countOnlyStatuses, isUncategorizedExpenseCategoryEnabled, statuses, } = action.payload;
+    const { isUncategorizedExpenseCategoryEnabled } = action.payload;
     const state = state$.value;
     const currentTenant = getCurrentTenant(state);
     const companyId = currentTenant.companyId;
@@ -61,10 +61,9 @@ export const refreshExpenseAutomationCurrentTabEpic = (actions$, state$) => acti
             }
         }
         case 'transaction_categorization':
-        default: {
+        default:
             return from([
-                fetchTransactionCategorizationView(selectedTransactionCategorizationTab, { start: timePeriodStart, end: timePeriodEnd }, true, false, undefined, undefined, true, undefined, isUncategorizedExpenseCategoryEnabled, statuses, countOnlyStatuses),
+                fetchTransactionCategorizationView(selectedTransactionCategorizationTab, { start: timePeriodStart, end: timePeriodEnd }, true, false, undefined, undefined, true, undefined, isUncategorizedExpenseCategoryEnabled),
             ]);
-        }
     }
 }));

package/lib/esm/view/expenseAutomationView/epics/missingReceipts/searchTransactionsForManualMatchEpic.js

@@ -5,9 +5,14 @@ import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePay
 import { rollingCalendarDateRangeInclusive } from '../../helpers/rollingCalendarDateRangeInclusive';
 import { supportedTransactionPayloadToManualSearchResult } from '../../payload/missingReceiptsPayload';
 import { searchTransactionsForManualMatch, searchTransactionsForManualMatchFailure, searchTransactionsForManualMatchSuccess, } from '../../reducers/missingReceiptsViewReducer';
+import { DEFAULT_COMPLETED_SUB_TAB } from '../../types/completedSubTab';
 import { toTransactionsSortKey } from '../../types/transactionsViewState';
 /**
-
+ * `auto_categorized` for manual transaction search (Unmatched).
+ * Backend contract TBD — align with `fetchTransactionCategorizationEpic` (`selectedTab === 'autoCategorized'`)
+ * when the expense-automation API documents the intended filter for this flow.
+ */
+export const MANUAL_TRANSACTION_SEARCH_AUTO_CATEGORIZED = false;
 /** Inclusive rolling window for manual match search (ignores accounting period picker). */
 const MANUAL_SEARCH_TRANSACTION_DATE_RANGE_DAYS = 90;
 export const searchTransactionsForManualMatchEpic = (actions$, state$, zeniAPI) => {
@@ -36,21 +41,20 @@ export const searchTransactionsForManualMatchEpic = (actions$, state$, zeniAPI)
         const queryParam = {
             start_date: start,
             end_date: end,
+            auto_categorized: MANUAL_TRANSACTION_SEARCH_AUTO_CATEGORIZED,
             sort_by: toTransactionsSortKey(manualSearchSortKey),
             sort_order: manualSearchSortOrder === 'ascending' ? 'asc' : 'desc',
             page_token: pageToken ?? null,
             page_size: manualSearch.pageSize,
             search_text: query,
+            // Manual search ignores the Completed sub-tab axis — always span the
+            // default sentinel so the receipt-matching UX returns results
+            // regardless of where the transaction would otherwise be bucketed on
+            // the Completed tab.
+            sub_tab: DEFAULT_COMPLETED_SUB_TAB,
         };
-        // BETA TEST — Shubham dev namespace for transaction-categorization
-        // `statuses` / `count_only_statuses` rollout. Revert before merge by
-        // restoring `${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}` in
-        // place of the hardcoded base. Mirrored in
-        // `fetchTransactionCategorizationEpic.ts` and
-        // `backgroundRefetchReviewTabEpic.ts` — grep `BETA TEST` to find
-        // every override site.
         return zeniAPI
-            .getJSON(`https://dev.api.zeni.ai/version/accounting/shubham/1.0/expense-automation/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
+            .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/expense-automation/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
             .pipe(mergeMap((response) => {
             if (isSuccessResponse(response) && response.data != null) {
                 const { transactions, next_page_token, total_count } = response.data;

package/lib/esm/view/expenseAutomationView/epics/transactionCategorization/backgroundRefetchReviewTabEpic.js

@@ -10,14 +10,8 @@ import { toTransactionsSortKey } from '../../types/transactionsViewState';
 const SELECTED_TAB = 'review';
 const PAGE_SIZE = 25;
 export const backgroundRefetchReviewTabEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(backgroundRefetchReviewTab.match), switchMap((action) => {
-    const { period, isUncategorizedExpenseCategoryEnabled, reviewStatuses } = action.payload;
+    const { period, isUncategorizedExpenseCategoryEnabled } = action.payload;
     const state = state$.value;
-    // Background refetch must never widen the listing to "all statuses".
-    // Dispatchers that have access to the Statsig-resolved Review-tab
-    // status set (e.g. the EA-screen save chain) pass it through on the
-    // action; everyone else falls back to the hardcoded sentinel so the
-    // refetch matches what the user sees on the Review tab.
-    const effectiveReviewStatuses = reviewStatuses ?? ['pending_review'];
     const currentTenant = getCurrentTenant(state);
     const selectedPeriod = state.expenseAutomationViewState.selectedPeriodByTenantId[currentTenant.tenantId];
     const reviewUiState = state.expenseAutomationTransactionsViewState
@@ -27,21 +21,14 @@ export const backgroundRefetchReviewTabEpic = (actions$, state$, zeniAPI) => act
         const queryParam = {
             start_date: toString(period.start),
             end_date: toString(period.end),
+            auto_categorized: false,
             sort_by: toTransactionsSortKey(reviewUiState.sortKey),
             sort_order: reviewUiState.sortOrder === 'ascending' ? 'asc' : 'desc',
             page_token: pageToken,
             page_size: PAGE_SIZE,
             search_text: reviewUiState.searchString,
-            statuses: effectiveReviewStatuses,
         };
-        // BETA TEST — Shubham dev namespace for transaction-categorization
-        // `statuses` / `count_only_statuses` rollout. Revert before merge by
-        // restoring `${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}` in
-        // place of the hardcoded base. Mirrored in
-        // `fetchTransactionCategorizationEpic.ts` and
-        // `searchTransactionsForManualMatchEpic.ts` — grep `BETA TEST` to
-        // find every override site.
-        return zeniAPI.getJSON(`https://dev.api.zeni.ai/version/accounting/shubham/1.0/expense-automation/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`);
+        return zeniAPI.getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/expense-automation/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`);
     };
     return fetchPage(null).pipe(expand((response) => {
         if (!isSuccessResponse(response) || response.data == null) {

package/lib/esm/view/expenseAutomationView/epics/transactionCategorization/fetchTransactionCategorizationEpic.js

@@ -6,10 +6,11 @@ import { updateTransactions } from '../../../../entity/transaction/transactionRe
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
 import { getLineItemsByTransactionsIdsFromResponse } from '../../helpers/transactionCategorizationLocalDataHelper';
 import { fetchTransactionCategorization, fetchTransactionCategorizationFailure, fetchTransactionCategorizationSuccess, initializeTransactionCategorizationViewLocalData, resetOtherTabsFetchState, updateParentTotalCountForTab, updateTotalCountForTransactionCategorization, updateTransactionCategorizationUIState, } from '../../reducers/transactionsViewReducer';
+import { DEFAULT_COMPLETED_SUB_TAB } from '../../types/completedSubTab';
 import { TRANSACTIONS_TABS, toTransactionsSortKey, } from '../../types/transactionsViewState';
 export const fetchTransactionCategorizationEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(fetchTransactionCategorization.match), switchMap((action) => {
     const { expenseAutomationViewState: { selectedPeriodByTenantId }, expenseAutomationTransactionsViewState, } = state$.value;
-    const { period, keepExistingListItems, selectedTab, refreshViewInBackground, statuses, countOnlyStatuses, } = action.payload;
+    const { period, keepExistingListItems, selectedTab, refreshViewInBackground, } = action.payload;
     const uiState = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTab].uiState;
     const { pageToken, sortOrder, sortKey } = uiState;
     const currentTenant = getCurrentTenant(state$.value);
@@ -17,23 +18,18 @@ export const fetchTransactionCategorizationEpic = (actions$, state$, zeniAPI) =>
     const queryParam = {
         start_date: toString(period.start),
         end_date: toString(period.end),
+        auto_categorized: selectedTab === 'autoCategorized',
         sort_by: toTransactionsSortKey(sortKey),
         sort_order: sortOrder === 'ascending' ? 'asc' : 'desc',
         page_token: pageToken,
         page_size: 25,
         search_text: uiState.searchString,
-        statuses,
-        count_only_statuses: countOnlyStatuses,
+        sub_tab: selectedTab === 'autoCategorized'
+            ? expenseAutomationTransactionsViewState.selectedTransactionCategorizationCompletedSubTab
+            : DEFAULT_COMPLETED_SUB_TAB,
     };
-    // BETA TEST — Shubham dev namespace for transaction-categorization
-    // `statuses` / `count_only_statuses` rollout. Revert before merge by
-    // restoring `${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}` in
-    // place of the hardcoded base. Mirrored in
-    // `backgroundRefetchReviewTabEpic.ts` and
-    // `searchTransactionsForManualMatchEpic.ts` — grep `BETA TEST` to
-    // find every override site.
     return zeniAPI
-        .getJSON(`https://dev.api.zeni.ai/version/accounting/shubham/1.0/expense-automation/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
+        .getJSON(`${zeniAPI.apiEndPoints.accountMicroServiceBaseUrl}/1.0/expense-automation/transactions?query=${encodeURIComponent(JSON.stringify(queryParam))}`)
         .pipe(mergeMap((response) => {
         if (isSuccessResponse(response) && response.data != null) {
             const updateActions = [];
@@ -56,11 +52,8 @@ export const fetchTransactionCategorizationEpic = (actions$, state$, zeniAPI) =>
             updateActions.push(updateParentTotalCountForTab({
                 selectedPeriod,
                 selectedTab,
-                // Optional — present only when the request supplied
-                // `count_only_statuses`. The reducer no-ops on undefined so
-                // any cached parent badge stays intact across scoped
-                // fetches (sort changes, pagination, etc.).
-                parentTotalCount: response.data.count_only_total,
+                parentTotalCount: response.data.parent_tab_total_count ??
+                    response.data.total_count,
             }));
             updateActions.push(resetOtherTabsFetchState({
                 refreshViewInBackground,

package/lib/esm/view/expenseAutomationView/epics/transactionCategorization/fetchTransactionCategorizationViewEpic.js

@@ -8,7 +8,7 @@ import { fetchOwnerList } from '../../../ownerList/ownerListReducer';
 import { fetchProjectList } from '../../../projectList/projectListReducer';
 import { fetchTransactionCategorization, fetchTransactionCategorizationView, } from '../../reducers/transactionsViewReducer';
 export const fetchTransactionCategorizationViewEpic = (actions$, state$) => actions$.pipe(filter(fetchTransactionCategorizationView.match), mergeMap((action) => {
-    const { selectedTab, cacheOverride, keepExistingListItems, pageToken, period, refreshViewInBackground, searchString, resetListItems, isUncategorizedExpenseCategoryEnabled, statuses, countOnlyStatuses, } = action.payload;
+    const { selectedTab, cacheOverride, keepExistingListItems, pageToken, period, refreshViewInBackground, searchString, resetListItems, isUncategorizedExpenseCategoryEnabled, } = action.payload;
     const updateActions = [];
     const { expenseAutomationTransactionsViewState } = state$.value;
     const { fetchState, transactionIdsBySelectedPeriod } = expenseAutomationTransactionsViewState.transactionCategorizationView[selectedTab];
@@ -42,7 +42,7 @@ export const fetchTransactionCategorizationViewEpic = (actions$, state$) => acti
     if (cacheOverride === true ||
         fetchState === 'Not-Started' ||
         transactionIds.length === 0) {
-        updateActions.push(fetchTransactionCategorization(selectedTab, period, cacheOverride, keepExistingListItems, searchString, pageToken, refreshViewInBackground, resetListItems, isUncategorizedExpenseCategoryEnabled, statuses, countOnlyStatuses));
+        updateActions.push(fetchTransactionCategorization(selectedTab, period, cacheOverride, keepExistingListItems, searchString, pageToken, refreshViewInBackground, resetListItems, isUncategorizedExpenseCategoryEnabled));
     }
     return from(updateActions);
 }));

package/lib/esm/view/expenseAutomationView/epics/transactionCategorization/markTransactionAsNotMiscategorizedEpic.js

@@ -10,7 +10,7 @@ import { getSnackbarMessageForTransactionReview } from '../../helpers/transactio
 import { fetchTransactionCategorizationView, markTransactionAsNotMiscategorized, updateStatusForTransactionNotMiscategorizedUpdateForCategorization, updateTotalCountForTransactionCategorization, } from '../../reducers/transactionsViewReducer';
 export const markTransactionAsNotMiscategorizedEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(markTransactionAsNotMiscategorized.match), mergeMap((action) => {
     const { expenseAutomationViewState, expenseAutomationTransactionsViewState, } = state$.value;
-    const { transactionsInReview, selectedTab, isUncategorizedExpenseCategoryEnabled, reviewStatuses: reviewStatusesFromAction, } = action.payload;
+    const { transactionsInReview, selectedTab, isUncategorizedExpenseCategoryEnabled, } = action.payload;
     const transactionsSuccess = transactionsInReview.transactions_update_success;
     const transactionsFailed = transactionsInReview.transactions_update_failed;
     const currentTenant = getCurrentTenant(state$.value);
@@ -105,20 +105,9 @@ export const markTransactionAsNotMiscategorizedEpic = (actions$, state$, zeniAPI
                     const timePeriodStart = toAbsoluteDay(period.start);
                     const timePeriodEnd = toAbsoluteDay(period.end);
                     if (timePeriodStart != null && timePeriodEnd != null) {
-                        // Statsig-resolved Review-tab statuses are threaded
-                        // through the EA save chain by `ExpenseAutomationScreen`
-                        // (resolves via `useDynamicConfig` +
-                        // `resolveTransactionCategorizationStatuses`). The
-                        // hardcoded `['pending_review']` last-resort prevents
-                        // accidental "all statuses" widening if the chain ever
-                        // delivers `undefined` (defensive — every live caller
-                        // should be passing this through).
-                        const reviewStatuses = reviewStatusesFromAction ?? [
-                            'pending_review',
-                        ];
                         actions.push(fetchTransactionCategorizationView('review', { start: timePeriodStart, end: timePeriodEnd }, true, // cacheOverride = true to force refresh
                         false, undefined, undefined, true, // refreshViewInBackground
-                        false, isUncategorizedExpenseCategoryEnabled, reviewStatuses));
+                        false, isUncategorizedExpenseCategoryEnabled));
                     }
                 }
                 actions.push(updateTotalCountForTransactionCategorization({

package/lib/esm/view/expenseAutomationView/epics/transactionCategorization/saveTransactionCategorizationEpic.js

@@ -6,7 +6,7 @@ import { getUncategorizedAccounts } from '../../../accountList/accountListSelect
 import { toTransactionUpdatesFromTransactionCategorizationLocalData } from '../../helpers/saveTransactionHelper';
 import { saveTransactionCategorization, updateTransactionCategorization, } from '../../reducers/transactionsViewReducer';
 export const saveTransactionCategorizationEpic = (actions$, state$) => actions$.pipe(filter(saveTransactionCategorization.match), mergeMap((action) => {
-    const { transactionIds, cotTrackingByTransactionId, selectedTab, isUncategorizedExpenseCategoryEnabled, reviewStatuses, } = action.payload;
+    const { transactionIds, cotTrackingByTransactionId, selectedTab, isUncategorizedExpenseCategoryEnabled, } = action.payload;
     const fetchActions = [];
     const { transactionState, expenseAutomationTransactionsViewState } = state$.value;
     const transactionSaveUpdates = [];
@@ -19,10 +19,6 @@ export const saveTransactionCategorizationEpic = (actions$, state$) => actions$.
             transactionSaveUpdates.push(toTransactionUpdatesFromTransactionCategorizationLocalData(localData, transaction, uncategorizedIncomeExpense));
         }
     });
-    // Forward `reviewStatuses` so the downstream
-    // `updateTransactionCategorizationEpic` -> `markTransactionAsNotMiscategorized`
-    // chain receives the Statsig-resolved Review-tab statuses end-to-end
-    // without reading Statsig from epic-land.
-    fetchActions.push(updateTransactionCategorization(selectedTab, transactionIds, transactionSaveUpdates, cotTrackingByTransactionId, isUncategorizedExpenseCategoryEnabled, reviewStatuses));
+    fetchActions.push(updateTransactionCategorization(selectedTab, transactionIds, transactionSaveUpdates, cotTrackingByTransactionId, isUncategorizedExpenseCategoryEnabled));
     return from(fetchActions);
 }));

package/lib/esm/view/expenseAutomationView/epics/transactionCategorization/triggerReviewTabRefetchEpic.js

@@ -4,7 +4,7 @@ import { convertToPeriod, toAbsoluteDay, } from '../../../../commonStateTypes/ti
 import { getCurrentTenant } from '../../../../entity/tenant/tenantSelector';
 import { backgroundRefetchReviewTab, syncTransactionCategorizationFromDetailSave, } from '../../reducers/transactionsViewReducer';
 export const triggerReviewTabRefetchEpic = (actions$, state$) => actions$.pipe(filter(syncTransactionCategorizationFromDetailSave.match), mergeMap((action) => {
-    const { pendingReviewLineIds, transactionId, isUncategorizedExpenseCategoryEnabled, reviewStatuses, } = action.payload;
+    const { pendingReviewLineIds, transactionId, isUncategorizedExpenseCategoryEnabled, } = action.payload;
     if (pendingReviewLineIds.length === 0) {
         return EMPTY;
     }
@@ -23,5 +23,5 @@ export const triggerReviewTabRefetchEpic = (actions$, state$) => actions$.pipe(f
     if (timePeriodStart == null || timePeriodEnd == null) {
         return EMPTY;
     }
-    return of(backgroundRefetchReviewTab({ start: timePeriodStart, end: timePeriodEnd }, isUncategorizedExpenseCategoryEnabled, reviewStatuses));
+    return of(backgroundRefetchReviewTab({ start: timePeriodStart, end: timePeriodEnd }, isUncategorizedExpenseCategoryEnabled));
 }));

package/lib/esm/view/expenseAutomationView/epics/transactionCategorization/updateTransactionCategorizationEpic.js

@@ -15,7 +15,7 @@ import { getVendorByVendorId } from '../../../../entity/vendor/vendorSelector';
 import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
 import { markTransactionAsNotMiscategorized, updateTransactionCategorization, updateTransactionCategorizationSaveStatus, } from '../../reducers/transactionsViewReducer';
 export const updateTransactionCategorizationEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(updateTransactionCategorization.match), mergeMap((action) => {
-    const { selectedTab, transactionIds, transactionSaveUpdates, cotTrackingByTransactionId, isUncategorizedExpenseCategoryEnabled, reviewStatuses, } = action.payload;
+    const { selectedTab, transactionIds, transactionSaveUpdates, cotTrackingByTransactionId, isUncategorizedExpenseCategoryEnabled, } = action.payload;
     const { transactionState, vendorState, expenseAutomationTransactionsViewState, } = state$.value;
     const payloadArray = preparePayload(selectedTab, transactionState, vendorState, expenseAutomationTransactionsViewState, transactionIds, transactionSaveUpdates, cotTrackingByTransactionId).filter((payload) => payload != null);
     return zeniAPI
@@ -24,11 +24,7 @@ export const updateTransactionCategorizationEpic = (actions$, state$, zeniAPI) =
         if (isSuccessResponse(response) && response.data != null) {
             const transactionsInReview = response.data;
             const actions = [];
-            // Forward `reviewStatuses` so the downstream
-            // `markTransactionAsNotMiscategorizedEpic` can request the
-            // Statsig-resolved Review-tab statuses for its conditional
-            // background refetch via `fetchTransactionCategorizationView`.
-            actions.push(markTransactionAsNotMiscategorized(selectedTab, transactionsInReview, isUncategorizedExpenseCategoryEnabled, reviewStatuses), updateTransactionCategorizationSaveStatus(selectedTab, 'Completed', createZeniAPIStatus('Completed', 'Transaction categorization updated successfully')));
+            actions.push(markTransactionAsNotMiscategorized(selectedTab, transactionsInReview, isUncategorizedExpenseCategoryEnabled), updateTransactionCategorizationSaveStatus(selectedTab, 'Completed', createZeniAPIStatus('Completed', 'Transaction categorization updated successfully')));
             return from(actions);
         }
         else {