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

package/lib/esm/view/companyView/epic/companyPassport/updateCapitalizationAccountThresholdEpic.js

@@ -0,0 +1,98 @@
+import { from } from 'rxjs';
+import { catchError, filter, mergeMap, switchMap } from 'rxjs/operators';
+import { updateCompanies } from '../../../../entity/company/companyReducer';
+import { openSnackbar } from '../../../../entity/snackbar/snackbarReducer';
+import { updateTenantCapitalizationOnboardingDismissed, updateTenantCapitalizationAccountOverride, } from '../../../../entity/tenant/tenantReducer';
+import { createZeniAPIStatus, isSuccessResponse, } from '../../../../responsePayload';
+import { updateCapitalizationAccountThreshold, updateCapitalizationAccountThresholdFailure, updateCapitalizationAccountThresholdSuccess, } from '../../companyViewReducer';
+export const updateCapitalizationAccountThresholdEpic = (actions$, state$, zeniAPI) => actions$.pipe(filter(updateCapitalizationAccountThreshold.match), switchMap((action) => {
+    const { companyId, accountId, threshold, dismissOnboardingForAccount, allOverrides, } = action.payload;
+    const tenantId = Object.values(state$.value.tenantState.tenantsById).find((t) => t.companyId === companyId)?.tenantId;
+    let finalOverrides;
+    if (allOverrides !== undefined) {
+        finalOverrides = allOverrides ?? {};
+    }
+    else {
+        finalOverrides = {
+            ...(tenantId != null
+                ? state$.value.tenantState.tenantsById[tenantId]
+                    ?.capitalizableAccountOverrides
+                : {}),
+        };
+        if (threshold === null) {
+            delete finalOverrides[accountId];
+        }
+        else {
+            finalOverrides[accountId] = threshold;
+        }
+    }
+    const body = {
+        capitalizable_account_overrides: Object.keys(finalOverrides).length > 0 ? finalOverrides : null,
+    };
+    if (dismissOnboardingForAccount === true) {
+        body.capitalization_onboarding_dismissed_accounts = { [accountId]: true };
+    }
+    return zeniAPI
+        .putAndGetJSON(`${zeniAPI.apiEndPoints.tenantMicroServiceBaseUrl}/1.0/companies/${companyId}`, body)
+        .pipe(mergeMap((response) => {
+        if (isSuccessResponse(response)) {
+            const companies = response.data?.companies ?? [];
+            const actions = [];
+            if (companies.length > 0) {
+                actions.push(updateCompanies({
+                    payload: companies,
+                    schema: {},
+                }));
+            }
+            if (tenantId != null) {
+                actions.push(updateTenantCapitalizationAccountOverride({
+                    tenantId,
+                    accountId,
+                    threshold,
+                    allOverrides: allOverrides !== undefined
+                        ? (Object.keys(finalOverrides).length > 0
+                            ? finalOverrides
+                            : null)
+                        : undefined,
+                }));
+                if (dismissOnboardingForAccount === true) {
+                    actions.push(updateTenantCapitalizationOnboardingDismissed({
+                        tenantId,
+                        accountId,
+                    }));
+                }
+            }
+            actions.push(updateCapitalizationAccountThresholdSuccess());
+            actions.push(openSnackbar({
+                messageSection: 'capitalization_threshold_update',
+                messageText: 'success',
+                type: 'success',
+            }));
+            return from(actions);
+        }
+        else {
+            return from([
+                updateCapitalizationAccountThresholdFailure({
+                    status: response.status,
+                }),
+                openSnackbar({
+                    messageSection: 'capitalization_threshold_update',
+                    messageText: 'failed',
+                    type: 'error',
+                }),
+            ]);
+        }
+    }), catchError((error) => from([
+        updateCapitalizationAccountThresholdFailure({
+            status: createZeniAPIStatus('Unexpected error', 'Update Capitalization Threshold errored out' +
+                (error instanceof Error
+                    ? error.message
+                    : JSON.stringify(error))),
+        }),
+        openSnackbar({
+            messageSection: 'capitalization_threshold_update',
+            messageText: 'failed',
+            type: 'error',
+        }),
+    ])));
+}));

package/lib/esm/view/companyView/epic/fetchAllCockpitViewsEpic.js

@@ -21,7 +21,7 @@ export const fetchAllCockpitViewsEpic = (actions$, state$) => actions$.pipe(filt
             fetchReviewCompanyView(),
             fetchCompanyHealthMetricView(),
             fetchCompanyMetaData(),
-            fetchCompanyTaskManagerView(null, 'dueDate', 'descending', false),
+            fetchCompanyTaskManagerView(0, 'dueDate', 'descending', false),
             fetchCompanyHealthMetricConfig(),
         ]);
     }
@@ -74,7 +74,7 @@ export const fetchAllCockpitViewsEpic = (actions$, state$) => actions$.pipe(filt
         }
         if (state.companyTaskManagerViewState.fetchState !== 'In-Progress' &&
             state.companyTaskManagerViewState.hasValidState() === false) {
-            fetchActions.push(fetchCompanyTaskManagerView(null, 'dueDate', 'descending', false));
+            fetchActions.push(fetchCompanyTaskManagerView(0, 'dueDate', 'descending', false));
         }
         return from(fetchActions);
     }

package/lib/esm/view/companyView/types/companyPassport/companyPassportViewState.js

@@ -5,6 +5,10 @@ export const initialCompanyPassportView = {
         fetchState: 'Not-Started',
         error: undefined,
     },
+    capitalizationThresholdUpdateStatus: {
+        fetchState: 'Not-Started',
+        error: undefined,
+    },
     companyDetails: {
         localData: undefined,
         updateStatus: {

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

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

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

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

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

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

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

@@ -0,0 +1,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) {