[Due for payment 2026-02-26] [$250] Reports - Unable to basic export expense when in group-by view

[mitarachim]

If you haven’t already, check out our contributing guidelines for onboarding and email contributors@expensify.com to request to join our Slack channel!

---

Version Number: 9.2.96-4
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: https://test-management.browserstack.com/projects/2219752/test-runs/TR-2733/folder/14961849/44236265/1113099972
Email or phone of affected tester (no customers): sjdosnjdoisjoisjojd@gmail.com
Issue reported by: Applause Internal Team
Bug source: Exploratory - Significant User Experience Deterioration
Device used: Mac 26.1 / Chrome
App Component: Search

Action Performed:

1. Go to staging.new.expensify.com
2. Go to workspace chat.
3. Create an expense.
4. Go to Reports > Expenses.
5. Click Filters.
6. Click Group by > select From.
7. Click Save > View results.
8. Expand the row.
9. Select the expense via checkbox.
10. Click dropdown button > Export > Basic export.

Expected Result:

The expense can be exported when in group-by result.

Actual Result:

Expense cannot be exported when in group-by result.

Workaround:

Unknown

Platforms:

• Android: App
• Android: mWeb Chrome
• iOS: App
• iOS: mWeb Safari
• iOS: mWeb Chrome
• Windows: Chrome
• MacOS: Chrome / Safari

Screenshots/Videos

Bug7044218_1767942925374.12.mp4

View all open jobs on GitHub

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022009749332551839029
• Upwork Job ID: 2009749332551839029
• Last Price Increase: 2026-01-28

Issue Owner

Current Issue Owner: @joekaufmanexpensify

[melvin-bot]

Triggered auto assignment to @joekaufmanexpensify (Bug), see https://stackoverflow.com/c/expensify/questions/14418 for more details. Please add this bug to a GH project, as outlined in the SO.

[TaduJR]

Proposal

Please re-state the problem that we are trying to solve in this issue.

When users are in the Reports > Expenses view with a group-by filter applied (e.g., Group by FROM), selecting expenses via checkbox and clicking Export > Basic export does not work. The expense cannot be exported when in group-by result view.

What is the root cause of that problem?

The setSelectedTransactions function in SearchContext.tsx does not handle group-by item types when building the selectedReports array.

Root Cause Flow:

1. User selects transactions in group-by view, triggering toggleTransaction in:
   

   App/src/components/Search/index.tsx

   Lines 656 to 709 in 49e60fa

   	const toggleTransaction = useCallback(
   	(item: SearchListItem, itemTransactions?: TransactionListItemType[]) => {
   	if (isReportActionListItemType(item)) {
   	return;
   	}
   	if (isTaskListItemType(item)) {
   	return;
   	}
   	if (isTransactionListItemType(item)) {
   	if (!item.keyForList) {
   	return;
   	}
   	if (isTransactionPendingDelete(item)) {
   	return;
   	}
   	const itemTransaction = transactions?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${item.transactionID}`] as OnyxEntry<Transaction>;
   	const originalItemTransaction = transactions?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${itemTransaction?.comment?.originalTransactionID}`];
   	setSelectedTransactions(
   	prepareTransactionsList(item, itemTransaction, originalItemTransaction, selectedTransactions, email ?? '', outstandingReportsByPolicyID),
   	filteredData,
   	);
   	return;
   	}
   	const currentTransactions = itemTransactions ?? item.transactions;
   	if (currentTransactions.some((transaction) => selectedTransactions[transaction.keyForList]?.isSelected)) {
   	const reducedSelectedTransactions: SelectedTransactions = {...selectedTransactions};
   	for (const transaction of currentTransactions) {
   	delete reducedSelectedTransactions[transaction.keyForList];
   	}
   	setSelectedTransactions(reducedSelectedTransactions, filteredData);
   	return;
   	}
   	setSelectedTransactions(
   	{
   	...selectedTransactions,
   	...Object.fromEntries(
   	currentTransactions
   	.filter((t) => !isTransactionPendingDelete(t))
   	.map((transactionItem) => {
   	const itemTransaction = searchResults?.data?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionItem.transactionID}`] as OnyxEntry<Transaction>;
   	const originalItemTransaction = searchResults?.data?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${itemTransaction?.comment?.originalTransactionID}`];
   	return mapTransactionItemToSelectedEntry(transactionItem, itemTransaction, originalItemTransaction, email ?? '', outstandingReportsByPolicyID);
   	}),
   	),
   	},
   	filteredData,
   	);
   	},
   	[setSelectedTransactions, selectedTransactions, filteredData, transactions, outstandingReportsByPolicyID, searchResults?.data, email],
   	);

2. setSelectedTransactions is called with filteredData containing group-by items (e.g., TransactionMemberGroupListItemType):
   

   App/src/components/Search/index.tsx

   Lines 692 to 706 in 49e60fa

   	setSelectedTransactions(
   	{
   	...selectedTransactions,
   	...Object.fromEntries(
   	currentTransactions
   	.filter((t) => !isTransactionPendingDelete(t))
   	.map((transactionItem) => {
   	const itemTransaction = searchResults?.data?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionItem.transactionID}`] as OnyxEntry<Transaction>;
   	const originalItemTransaction = searchResults?.data?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${itemTransaction?.comment?.originalTransactionID}`];
   	return mapTransactionItemToSelectedEntry(transactionItem, itemTransaction, originalItemTransaction, email ?? '', outstandingReportsByPolicyID);
   	}),
   	),
   	},
   	filteredData,
   	);

3. In SearchContext.tsx, the function only handles two data types:
   

   App/src/components/Search/SearchContext.tsx

   Lines 91 to 117 in 49e60fa

   	let selectedReports: SearchContextProps['selectedReports'] = [];
   	if (data.length && data.every(isTransactionReportGroupListItemType)) {
   	selectedReports = data
   	.filter((item) => isMoneyRequestReport(item) && item.transactions.length > 0 && item.transactions.every(({keyForList}) => selectedTransactions[keyForList]?.isSelected))
   	.map(({reportID, action = CONST.SEARCH.ACTION_TYPES.VIEW, total = CONST.DEFAULT_NUMBER_ID, policyID, allActions = [action], currency, chatReportID}) => ({
   	reportID,
   	action,
   	total,
   	policyID,
   	allActions,
   	currency,
   	chatReportID,
   	}));
   	} else if (data.length && data.every(isTransactionListItemType)) {
   	selectedReports = data
   	.filter(({keyForList}) => !!keyForList && selectedTransactions[keyForList]?.isSelected)
   	.map(({reportID, action = CONST.SEARCH.ACTION_TYPES.VIEW, amount: total = CONST.DEFAULT_NUMBER_ID, policyID, allActions = [action], currency, report}) => ({
   	reportID,
   	action,
   	total,
   	policyID,
   	allActions,
   	currency,
   	chatReportID: report?.chatReportID,
   	}));
   	}

if (data.length && data.every(isTransactionReportGroupListItemType)) {
    // Handles expense-report type only
} else if (data.length && data.every(isTransactionListItemType)) {
    // Handles individual transactions only
}
// NO handling for group-by types:
// - TransactionMemberGroupListItemType (groupBy === 'from')
// - TransactionCardGroupListItemType (groupBy === 'card')
// - TransactionWithdrawalIDGroupListItemType (groupBy === 'withdrawalID')

4. The type guards don't match group-by items:

   • isTransactionReportGroupListItemType checks groupedBy === CONST.SEARCH.DATA_TYPES.EXPENSE_REPORT:
     

     App/src/libs/SearchUIUtils.ts

     Lines 836 to 838 in 49e60fa

     	function isTransactionReportGroupListItemType(item: ListItem): item is TransactionReportGroupListItemType {
     	return isTransactionGroupListItemType(item) && 'groupedBy' in item && item.groupedBy === CONST.SEARCH.DATA_TYPES.EXPENSE_REPORT;
     	}

   • Group-by items have different groupedBy values (e.g., 'from', 'card', 'withdrawalID')

5. Result: selectedReports stays empty, causing export to receive empty reportIDList:
   

   App/src/pages/Search/SearchPage.tsx

   Lines 462 to 467 in 49e60fa

   	exportSearchItemsToCSV(
   	{
   	query: status,
   	jsonQuery: JSON.stringify(queryJSON),
   	reportIDList: selectedReports?.map((report) => report?.reportID).filter((reportID) => reportID !== undefined) ?? [],
   	transactionIDList: selectedTransactionsKeys,

What changes do you think we should make in order to solve the problem?

Add handling for group-by item types in setSelectedTransactions function.

File: src/components/Search/SearchContext.tsx

App/src/components/Search/SearchContext.tsx

Lines 91 to 117 in 49e60fa

	let selectedReports: SearchContextProps['selectedReports'] = [];
	if (data.length && data.every(isTransactionReportGroupListItemType)) {
	selectedReports = data
	.filter((item) => isMoneyRequestReport(item) && item.transactions.length > 0 && item.transactions.every(({keyForList}) => selectedTransactions[keyForList]?.isSelected))
	.map(({reportID, action = CONST.SEARCH.ACTION_TYPES.VIEW, total = CONST.DEFAULT_NUMBER_ID, policyID, allActions = [action], currency, chatReportID}) => ({
	reportID,
	action,
	total,
	policyID,
	allActions,
	currency,
	chatReportID,
	}));
	} else if (data.length && data.every(isTransactionListItemType)) {
	selectedReports = data
	.filter(({keyForList}) => !!keyForList && selectedTransactions[keyForList]?.isSelected)
	.map(({reportID, action = CONST.SEARCH.ACTION_TYPES.VIEW, amount: total = CONST.DEFAULT_NUMBER_ID, policyID, allActions = [action], currency, report}) => ({
	reportID,
	action,
	total,
	policyID,
	allActions,
	currency,
	chatReportID: report?.chatReportID,
	}));
	}

Solution:

Add a third condition to handle all group-by list item types (TransactionMemberGroupListItemType, TransactionCardGroupListItemType, TransactionWithdrawalIDGroupListItemType). These types all extend TransactionGroupListItemType and have a transactions array containing TransactionListItemType items.

import {isTransactionGroupListItemType} from '@libs/SearchUIUtils';

// Inside setSelectedTransactions function, after existing conditions:

if (data.length && data.every(isTransactionReportGroupListItemType)) {
    // existing expense-report handling
    selectedReports = data
        .filter((item) => isMoneyRequestReport(item) && item.transactions.length > 0 && item.transactions.every(({keyForList}) => selectedTransactions[keyForList]?.isSelected))
        .map(({reportID, action = CONST.SEARCH.ACTION_TYPES.VIEW, total = CONST.DEFAULT_NUMBER_ID, policyID, allActions = [action], currency, chatReportID}) => ({
            reportID,
            action,
            total,
            policyID,
            allActions,
            currency,
            chatReportID,
        }));
} else if (data.length && data.every(isTransactionListItemType)) {
    // existing individual transaction handling
    selectedReports = data
        .filter(({keyForList}) => !!keyForList && selectedTransactions[keyForList]?.isSelected)
        .map(({reportID, action = CONST.SEARCH.ACTION_TYPES.VIEW, amount: total = CONST.DEFAULT_NUMBER_ID, policyID, allActions = [action], currency, report}) => ({
            reportID,
            action,
            total,
            policyID,
            allActions,
            currency,
            chatReportID: report?.chatReportID,
        }));
} else if (data.length && data.every(isTransactionGroupListItemType)) {
    // NEW: Handle group-by types (FROM, CARD, WITHDRAWAL_ID)
    // Extract selected transactions from all groups and build selectedReports
    const selectedTransactionItems = data.flatMap((group) =>
        group.transactions.filter(({keyForList}) => !!keyForList && selectedTransactions[keyForList]?.isSelected)
    );
    selectedReports = selectedTransactionItems.map(({reportID, action = CONST.SEARCH.ACTION_TYPES.VIEW, amount: total = CONST.DEFAULT_NUMBER_ID, policyID, allActions = [action], currency, report}) => ({
        reportID,
        action,
        total,
        policyID,
        allActions,
        currency,
        chatReportID: report?.chatReportID,
    }));
}

The import for isTransactionGroupListItemType is already available:

App/src/libs/SearchUIUtils.ts

Lines 828 to 832 in 49e60fa

	*/
	function isTransactionGroupListItemType(item: ListItem): item is TransactionGroupListItemType {
	return 'transactions' in item;
	}

This ensures that when transactions are selected in any group-by view, the selectedReports array is properly populated with report information extracted from the nested transactions.

What alternative solutions did you explore? (Optional)

1. Add specific handlers for each group-by type - Could add separate conditions for isTransactionMemberGroupListItemType, isTransactionCardGroupListItemType, isTransactionWithdrawalIDGroupListItemType. However, since they all extend TransactionGroupListItemType and share the same transactions structure, using the base type guard is cleaner and more maintainable.

2. Modify export function to work without reportIDList - The export function could be modified to derive report IDs from transaction IDs. However, this would be a workaround rather than fixing the actual selection state management issue.

[twinkle-react]

🚨 Edited by proposal-police: This proposal was edited at 2026-01-10 04:53:23 UTC.

Proposal

Please re-state the problem that we are trying to solve in this issue.

Basic export fails in grouped Expenses views because selected grouped expenses yield an empty reportIDList, so no CSV is produced.

What is the root cause of that problem?

setSelectedTransactions does not populate selectedReports for group-by list items, and the export handler only uses selectedReports, leading to an empty reportIDList.

// setSelectedTransactions currently lacks group-by handling

if (data.length && data.every(isTransactionReportGroupListItemType)) { ... }
else if (data.length && data.every(isTransactionListItemType)) { ... }
// missing: isTransactionGroupListItemType branch for grouped rows

What changes do you think we should make in order to solve the problem?

1. Populate selectedReports when the data array contains any transaction group-by items.
2. Keep a compact, deduping export fallback so export succeeds even if selectedReports is empty.

- import {isTransactionListItemType, isTransactionReportGroupListItemType} from '@libs/SearchUIUtils';
+ import {isTransactionGroupListItemType, isTransactionListItemType, isTransactionReportGroupListItemType} from '@libs/SearchUIUtils';

... } else if (data.length && data.every(isTransactionListItemType)) {
    selectedReports = data
        .filter(({keyForList}) => !!keyForList && selectedTransactions[keyForList]?.isSelected)
        .map(({reportID, action = CONST.SEARCH.ACTION_TYPES.VIEW, amount: total = CONST.DEFAULT_NUMBER_ID, policyID, allActions = [action], currency, report}) => ({
            reportID,
            action,
            total,
            policyID,
            allActions,
            currency,
            chatReportID: report?.chatReportID,
        }));
+} else if (data.length && data.every(isTransactionGroupListItemType)) {
+    // Grouped rows (from/card/withdrawal)
+    const selectedItems = data.flatMap((group) =>
+        group.transactions.filter(({keyForList}) => !!keyForList && selectedTransactions[keyForList]?.isSelected),
+    );
+    selectedReports = selectedItems.map(({reportID, action = CONST.SEARCH.ACTION_TYPES.VIEW, amount: total = CONST.DEFAULT_NUMBER_ID, policyID, allActions = [action], currency, report}) => ({
+        reportID,
+        action,
+        total,
+        policyID,
+        allActions,
+        currency,
+        chatReportID: report?.chatReportID,
+    }));
}

- const reportIDListFromSelection =
-     selectedReports?.filter((report) => !!report).map((report) => report.reportID) ?? [];
- const derivedReportIDList =
-     reportIDListFromSelection.length > 0
-         ? reportIDListFromSelection
-         : Object.values(selectedTransactions)
-               .map((transaction) => transaction.reportID)
-               .filter(Boolean);
+ const derivedReportIDList = Array.from(
+     new Set(
+         (selectedReports?.map((r) => r.reportID).filter(Boolean)?.length ?? 0) > 0
+             ? selectedReports.map((r) => r.reportID).filter(Boolean)
+             : Object.values(selectedTransactions).map((t) => t.reportID).filter(Boolean),
+     ),
+ );

What alternative solutions did you explore? (Optional)

N/A

[melvin-bot]

Job added to Upwork: https://www.upwork.com/jobs/~022009749332551839029

[melvin-bot]

Triggered auto assignment to Contributor-plus team member for initial proposal review - @akinwale (External)

[truph01]

Proposal

Please re-state the problem that we are trying to solve in this issue.

• Reports - Unable to basic export expense when in group-by view

What is the root cause of that problem?

• There are two issues contributing to this:

1. The API call used for basic export

   App/src/libs/actions/Search.ts

   Line 891 in 073940f

   const finalParameters = enhanceParameters(WRITE_COMMANDS.EXPORT_SEARCH_ITEMS_TO_CSV, {

   fails when the app is in group-by view. The backend returns the following error:

{
    "jsonCode": 0,
    "message": "No column named reportID",
    "source": "auth-via-api",
    "onyxData": [],
    "requestID": "9bbb4d514aef856a-HKG"
}

2. The reportID values corresponding to the selected transactions are never sent to the backend in this API request.

• When the user clicks "Basic export", the app triggers the export logic here:
  

  App/src/pages/Search/SearchPage.tsx

  Lines 462 to 467 in 073940f

  	exportSearchItemsToCSV(
  	{
  	query: status,
  	jsonQuery: JSON.stringify(queryJSON),
  	reportIDList: selectedReports?.map((report) => report?.reportID).filter((reportID) => reportID !== undefined) ?? [],
  	transactionIDList: selectedTransactionsKeys,

• In this logic, reportIDList is derived from selectedReports, which remains empty when selecting transactions in the group-by view.

What changes do you think we should make in order to solve the problem?

• The first issue (API error) needs to be addressed on the backend.

• For the second issue, we should update the client-side export logic to derive reportIDList from selectedTransactions when selectedReports is empty.

App/src/pages/Search/SearchPage.tsx

Line 466 in 073940f

reportIDList: selectedReports?.map((report) => report?.reportID).filter((reportID) => reportID !== undefined) ?? [],

reportIDList:
    selectedReports.length > 0
        ? (selectedReports.map((report) => report?.reportID).filter((reportID) => reportID !== undefined) ?? [])
        : (Object.values(selectedTransactions ?? {}).map((transaction) => transaction?.reportID) ?? []),
transactionIDList: selectedTransactionsKeys,

This fallback ensures that when reports aren't explicitly selected (as in group-by view), we still collect the relevant reportIDs from the selected transactions.

What alternative solutions did you explore? (Optional)