[Due for payment 2026-02-24] Deleting a draft report from search deletes the expenses as well.

[trjExpensify]

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:**v9.3.3-2
Reproducible in staging?: Y
**Reproducible in production?:**Y
If this was caught during regression testing, add the test name, ID and link from BrowserStack: No
Issue reported by: @trjExpensify
Slack conversation (hyperlinked to channel name): NA, discovered in testing something else.

Action Performed:

1. Create a report
2. Add two expenses to it
3. Go to Reports > Reports
4. Select the report
5. Click Delete > Confirm
6. Observe the report is deleted and the expenses are deleted.

Expected Result:

The report should be deleted, and the expenses should be unreported.

Actual Result:

The report is deleted and the expenses are deleted.

I think this might be because we seem to be calling DeleteMoneyRequestOnSearch when you've bulk selected type:expense-report results, instead of maybe DeleteAppReport which when called from within the report directly seems to work as expected. 🤔

Additionally, we should only surface report specific actions when viewing Search results with type:expense-report. Those actions are:

• Submit
• Approve
• Pay
• Export
• Delete (we should also allow selecting/deleting empty reports as part of this issue, see [HOLD 79756] [$250] Unable to Select Empty Reports for Deletion in Reports > Reports #79000)

Workaround:

Click into the report > More > Delete. The report will be deleted, and the expenses unreported.

Platforms:

Select the officially supported platforms where the issue was reproduced:

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

Screenshots/Videos

2026-01-16_03-10-17.mp4

View all open jobs on GitHub

Issue Owner

Current Issue Owner: @trjExpensify

[melvin-bot]

Current assignee @trjExpensify is eligible for the Bug assigner, not assigning anyone new.

[melvin-bot]

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

[daledah]

🚨 Edited by proposal-police: This proposal was edited at 2026-01-16 10:46:55 UTC.

Proposal

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

When bulk deleting an expense report from Reports > Reports (selecting a report and clicking Delete), the expenses inside the report are also deleted instead of being unreported (moved back to draft/unreported state).

What is the root cause of that problem?

The root cause is in src/pages/Search/SearchPage.tsx in the onBulkDeleteSelected callback. When deleting items from search results, it always calls deleteMoneyRequestOnSearch which deletes the transactions:

App/src/pages/Search/SearchPage.tsx

Lines 428 to 460 in e9f4cf3

	const handleDeleteSelectedTransactions = useCallback(async () => {
	if (isOffline) {
	setIsOfflineModalVisible(true);
	return;
	}
	if (!hash) {
	return;
	}
	// Use InteractionManager to ensure this runs after the dropdown modal closes
	// eslint-disable-next-line @typescript-eslint/no-deprecated
	InteractionManager.runAfterInteractions(async () => {
	const result = await showConfirmModal({
	title: translate('iou.deleteExpense', {count: selectedTransactionsKeys.length}),
	prompt: translate('iou.deleteConfirmation', {count: selectedTransactionsKeys.length}),
	confirmText: translate('common.delete'),
	cancelText: translate('common.cancel'),
	danger: true,
	});
	if (result.action !== ModalActions.CONFIRM) {
	return;
	}
	// Translations copy for delete modal depends on amount of selected items,
	// We need to wait for modal to fully disappear before clearing them to avoid translation flicker between singular vs plural
	// eslint-disable-next-line @typescript-eslint/no-deprecated
	InteractionManager.runAfterInteractions(() => {
	deleteMoneyRequestOnSearch(hash, selectedTransactionsKeys);
	clearSelectedTransactions();
	});
	});
	}, [isOffline, showConfirmModal, translate, selectedTransactionsKeys, hash, clearSelectedTransactions]);

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

Modify onBulkDeleteSelected in src/pages/Search/SearchPage.tsx to check if we're in expense-report view. If so, call deleteAppReport for each selected report instead of deleteMoneyRequestOnSearch for transactions.

// src/pages/Search/SearchPage.tsx

+import {deleteAppReport} from '@libs/actions/Report';

// Inside onBulkDeleteSelected callback, replace:
-           InteractionManager.runAfterInteractions(() => {
-               deleteMoneyRequestOnSearch(hash, selectedTransactionsKeys);
-               clearSelectedTransactions();
-           });

// With:
+           const isExpenseReportType = queryJSON?.type === CONST.SEARCH.DATA_TYPES.EXPENSE_REPORT;
+           InteractionManager.runAfterInteractions(() => {
+               if (isExpenseReportType) {
+                   for (const reportID of selectedReportIDs) {
+                       deleteAppReport(reportID, currentUserPersonalDetails?.login ?? '', allTransactions ?? {}, allTransactionViolations, bankAccountList);
+                   }
+               } else {
+                   deleteMoneyRequestOnSearch(hash, selectedTransactionsKeys);
+               }
+               clearSelectedTransactions();
+           });

// Update dependency array to include new dependencies:
-}, [isOffline, showConfirmModal, translate, selectedTransactionsKeys, hash, clearSelectedTransactions]);
+}, [isOffline, showConfirmModal, translate, selectedTransactionsKeys, hash, clearSelectedTransactions, queryJSON?.type, selectedReportIDs, currentUserPersonalDetails?.login, allTransactions, allTransactionViolations, bankAccountList]);

What alternative solutions did you explore? (Optional)

Another option would be to modify deleteMoneyRequestOnSearch to accept a parameter indicating whether to delete or unreport the transactions. However, this would require backend changes and is more complex. Using the existing deleteAppReport function is cleaner since it already handles the unreporting logic correctly.

[abbasifaizan70]

Proposal

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

When a user creates a report with expenses and then deletes the report from the Reports > Reports page (search results showing type:expense-report), the expenses are being deleted permanently instead of being unreported. This differs from the expected behavior where deleting a report should unreport the expenses, making them available to be added to other reports.

What is the root cause of that problem?

The root cause is in the handleDeleteSelectedTransactions function in SearchPage.tsx. When deleting items from the search results, it always calls deleteMoneyRequestOnSearch regardless of whether the user is deleting expense reports or individual transactions.

The problematic code:

App/src/pages/Search/SearchPage.tsx

Line 456 in e94f05d

deleteMoneyRequestOnSearch(hash, selectedTransactionsKeys);

The function deleteMoneyRequestOnSearch is designed to delete individual transactions:

App/src/libs/actions/Search.ts

Lines 725 to 760 in e94f05d

	function deleteMoneyRequestOnSearch(hash: number, transactionIDList: string[]) {
	const {optimisticData: loadingOptimisticData, finallyData} = getOnyxLoadingData(hash);
	for (const transactionID of transactionIDList) {
	// @ts-expect-error - will be solved in https://github.com/Expensify/App/issues/73830
	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
	const optimisticData: OnyxUpdate[] = [
	...loadingOptimisticData,
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${hash}`,
	value: {
	data: {
	[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`]: {pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE},
	},
	},
	},
	];
	const failureData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.SNAPSHOT>> = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.SNAPSHOT}${hash}`,
	value: {
	data: {
	// @ts-expect-error - will be solved in https://github.com/Expensify/App/issues/73830
	// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
	[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`]: {pendingAction: null},
	},
	},
	},
	];
	API.write(WRITE_COMMANDS.DELETE_MONEY_REQUEST_ON_SEARCH, {hash, transactionIDList: [transactionID]}, {optimisticData, failureData, finallyData});
	}
	}

This function marks transactions with pendingAction: DELETE and deletes them permanently. However, when called from the Reports page (where queryJSON.type === CONST.SEARCH.DATA_TYPES.EXPENSE_REPORT), it should instead call deleteAppReport, which properly unreports the expenses.

The correct function that should be used for reports:

App/src/libs/actions/Report.ts

Lines 4968 to 5330 in e94f05d

	function deleteAppReport(
	reportID: string | undefined,
	currentUserEmailParam: string,
	reportTransactions: Record<string, Transaction>,
	allTransactionViolations: OnyxCollection<TransactionViolations>,
	bankAccountList: OnyxEntry<BankAccountList>,
	) {
	if (!reportID) {
	Log.warn('[Report] deleteReport called with no reportID');
	return;
	}
	const optimisticData: Array<
	OnyxUpdate<
	| typeof ONYXKEYS.COLLECTION.REPORT
	| typeof ONYXKEYS.COLLECTION.REPORT_METADATA
	| typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS
	| typeof ONYXKEYS.COLLECTION.TRANSACTION
	| typeof ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS
	>
	> = [];
	const successData: Array<OnyxUpdate<typeof ONYXKEYS.COLLECTION.REPORT | typeof ONYXKEYS.COLLECTION.REPORT_METADATA | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS>> = [];
	const failureData: Array<
	OnyxUpdate<typeof ONYXKEYS.COLLECTION.TRANSACTION | typeof ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS | typeof ONYXKEYS.COLLECTION.REPORT_ACTIONS | typeof ONYXKEYS.COLLECTION.REPORT>
	> = [];
	const report = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`];
	let selfDMReportID = findSelfDMReportID();
	let selfDMReport = allReports?.[`${ONYXKEYS.COLLECTION.REPORT}${selfDMReportID}`];
	let createdAction: ReportAction;
	let selfDMParameters: SelfDMParameters = {};
	if (!selfDMReport) {
	const currentTime = DateUtils.getDBTime();
	selfDMReport = buildOptimisticSelfDMReport(currentTime);
	selfDMReportID = selfDMReport.reportID;
	createdAction = buildOptimisticCreatedReportAction(currentUserEmailParam ?? '', currentTime);
	selfDMParameters = {reportID: selfDMReport.reportID, createdReportActionID: createdAction.reportActionID};
	optimisticData.push(
	{
	onyxMethod: Onyx.METHOD.SET,
	key: `${ONYXKEYS.COLLECTION.REPORT}${selfDMReport.reportID}`,
	value: {
	...selfDMReport,
	pendingFields: {
	createChat: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
	},
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_METADATA}${selfDMReport.reportID}`,
	value: {
	isOptimisticReport: true,
	},
	},
	{
	onyxMethod: Onyx.METHOD.SET,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${selfDMReport.reportID}`,
	value: {
	[createdAction.reportActionID]: createdAction,
	},
	},
	);
	successData.push(
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${selfDMReport.reportID}`,
	value: {
	pendingFields: {
	createChat: null,
	},
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_METADATA}${selfDMReport.reportID}`,
	value: {
	isOptimisticReport: false,
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${selfDMReport.reportID}`,
	value: {
	[createdAction.reportActionID]: {
	pendingAction: null,
	},
	},
	},
	);
	}
	// 1. Get all report transactions
	const reportActionsForReport = allReportActions?.[reportID];
	const transactionIDToReportActionAndThreadData: Record<string, TransactionThreadInfo> = {};
	for (const reportAction of Object.values(reportActionsForReport ?? {})) {
	if (!ReportActionsUtils.isMoneyRequestAction(reportAction)) {
	continue;
	}
	if (ReportActionsUtils.isDeletedAction(reportAction)) {
	continue;
	}
	const originalMessage = ReportActionsUtils.getOriginalMessage(reportAction);
	if (originalMessage?.type !== CONST.IOU.REPORT_ACTION_TYPE.CREATE && originalMessage?.type !== CONST.IOU.REPORT_ACTION_TYPE.TRACK) {
	continue;
	}
	const transactionID = ReportActionsUtils.getOriginalMessage(reportAction)?.IOUTransactionID;
	const childReportID = reportAction.childReportID;
	const newReportActionID = rand64();
	// 1. Update the transaction and its violations
	if (transactionID) {
	const transaction = reportTransactions[`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`];
	const transactionViolations = allTransactionViolations?.[`${ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS}${transactionID}`] ?? [];
	optimisticData.push(
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`,
	value: {reportID: CONST.REPORT.UNREPORTED_REPORT_ID, comment: {hold: null}},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS}${transactionID}`,
	value: null,
	},
	);
	failureData.push(
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`,
	value: {reportID: transaction?.reportID, comment: {hold: transaction?.comment?.hold}},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS}${transactionID}`,
	value: transactionViolations,
	},
	);
	if (isOnHold(transaction)) {
	const unHoldAction = buildOptimisticUnHoldReportAction();
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${childReportID}`,
	value: {[unHoldAction.reportActionID]: unHoldAction},
	});
	successData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${childReportID}`,
	value: {[unHoldAction.reportActionID]: {pendingAction: null}},
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${childReportID}`,
	value: {[unHoldAction.reportActionID]: null},
	});
	transactionIDToReportActionAndThreadData[transactionID] = {
	...transactionIDToReportActionAndThreadData[transactionID],
	unholdReportActionID: unHoldAction.reportActionID,
	};
	}
	}
	// 2. Move the report action to self DM
	const updatedReportAction = {
	...reportAction,
	originalMessage: {
	// eslint-disable-next-line @typescript-eslint/no-deprecated
	...reportAction.originalMessage,
	IOUReportID: CONST.REPORT.UNREPORTED_REPORT_ID,
	type: CONST.IOU.TYPE.TRACK,
	},
	reportActionID: newReportActionID,
	pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
	};
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${selfDMReportID}`,
	value: {[newReportActionID]: updatedReportAction},
	});
	successData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${selfDMReportID}`,
	value: {[newReportActionID]: {pendingAction: null}},
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${selfDMReportID}`,
	value: {[newReportActionID]: null},
	});
	// 3. Update transaction thread
	optimisticData.push(
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${childReportID}`,
	value: {
	parentReportActionID: newReportActionID,
	parentReportID: selfDMReportID,
	chatReportID: selfDMReportID,
	policyID: CONST.POLICY.ID_FAKE,
	},
	},
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${childReportID}`,
	value: {
	[newReportActionID]: {
	actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
	originalMessage: {
	IOUTransactionID: transactionID,
	movedToReportID: selfDMReportID,
	},
	},
	},
	},
	);
	// 4. Add UNREPORTED_TRANSACTION report action
	const unreportedAction = buildOptimisticUnreportedTransactionAction(childReportID, reportID);
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${childReportID}`,
	value: {[unreportedAction.reportActionID]: unreportedAction},
	});
	successData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${childReportID}`,
	value: {[unreportedAction.reportActionID]: {pendingAction: null}},
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${childReportID}`,
	value: {[unreportedAction.reportActionID]: null},
	});
	if (transactionID) {
	transactionIDToReportActionAndThreadData[transactionID] = {
	...transactionIDToReportActionAndThreadData[transactionID],
	moneyRequestPreviewReportActionID: newReportActionID,
	movedReportActionID: unreportedAction?.reportActionID,
	};
	}
	}
	// 6. Delete report actions on the report
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
	value: null,
	});
	// @ts-expect-error - will be solved in https://github.com/Expensify/App/issues/73830
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
	value: reportActionsForReport,
	});
	// 7. Mark the iouReport as being deleted and then delete it
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
	value: {
	pendingFields: {
	preview: CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE,
	},
	},
	});
	successData.push({
	onyxMethod: Onyx.METHOD.SET,
	key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
	value: null,
	});
	// @ts-expect-error - will be solved in https://github.com/Expensify/App/issues/73830
	failureData.push({
	onyxMethod: Onyx.METHOD.SET,
	key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
	value: report,
	});
	// 8. Mark chat report preview action as deleted
	const reportActionID = report?.parentReportActionID;
	const parentReportID = report?.parentReportID;
	const parentReportAction = parentReportID && reportActionID ? allReportActions?.[parentReportID]?.[reportActionID] : undefined;
	if (reportActionID) {
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReportID}`,
	value: {
	[reportActionID]: {
	pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.DELETE,
	},
	},
	});
	successData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReportID}`,
	value: {
	[reportActionID]: {
	pendingAction: null,
	errors: null,
	},
	},
	});
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReportID}`,
	value: {
	[reportActionID]: {
	...parentReportAction,
	errors: getMicroSecondOnyxErrorWithTranslationKey('iou.error.genericDeleteFailureMessage'),
	},
	},
	});
	}
	const chatReport = getReportOrDraftReport(report?.parentReportID);
	if (chatReport) {
	optimisticData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${report?.parentReportID}`,
	value: {hasOutstandingChildRequest: hasOutstandingChildRequest(chatReport, report?.reportID, currentUserEmailParam, allTransactionViolations, bankAccountList)},
	});
	}
	failureData.push({
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${report?.parentReportID}`,
	value: {hasOutstandingChildRequest: report?.hasOutstandingChildRequest},
	});
	const parameters: DeleteAppReportParams = {
	reportID,
	transactionIDToReportActionAndThreadData: JSON.stringify(transactionIDToReportActionAndThreadData),
	selfDMReportID: selfDMParameters.reportID,
	selfDMCreatedReportActionID: selfDMParameters.createdReportActionID,
	};
	API.write(WRITE_COMMANDS.DELETE_APP_REPORT, parameters, {optimisticData, successData, failureData});
	}

The deleteAppReport function is already being used correctly when deleting reports from other contexts, such as from within the report view itself:

App/src/pages/home/report/ContextMenu/PopoverReportActionContextMenu.tsx

Line 371 in e94f05d

deleteAppReport(reportAction.childReportID, email ?? '', reportTransactions, allTransactionViolations, bankAccountList);

Why it works differently from within the report:

When deleting a report from within the report details page or from the context menu, the code correctly calls deleteAppReport, which:

1. Deletes the report
2. Unreports all transactions (sets them back to unreported state)
3. Maintains transaction data so expenses can be added to other reports

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

Modify the handleDeleteSelectedTransactions function in SearchPage.tsx to check the query type and call the appropriate delete function based on whether we're deleting reports or transactions.

Implementation Steps:

1. Import deleteAppReport from @libs/actions/Report in SearchPage.tsx:

import {deleteAppReport, moveIOUReportToPolicy, moveIOUReportToPolicyAndInviteSubmitter, searchInServer} from '@libs/actions/Report';

App/src/pages/Search/SearchPage.tsx

Line 40 in e94f05d

import {moveIOUReportToPolicy, moveIOUReportToPolicyAndInviteSubmitter, searchInServer} from '@libs/actions/Report';

2. Modify the handleDeleteSelectedTransactions function to check the query type:

const handleDeleteSelectedTransactions = useCallback(async () => {
    if (isOffline) {
        setIsOfflineModalVisible(true);
        return;
    }

    if (!hash) {
        return;
    }

    // Use InteractionManager to ensure this runs after the dropdown modal closes
    // eslint-disable-next-line @typescript-eslint/no-deprecated
    InteractionManager.runAfterInteractions(async () => {
        const result = await showConfirmModal({
            title: translate('iou.deleteExpense', {count: selectedTransactionsKeys.length}),
            prompt: translate('iou.deleteConfirmation', {count: selectedTransactionsKeys.length}),
            confirmText: translate('common.delete'),
            cancelText: translate('common.cancel'),
            danger: true,
        });
        if (result.action !== ModalActions.CONFIRM) {
            return;
        }
        // Translations copy for delete modal depends on amount of selected items,
        // We need to wait for modal to fully disappear before clearing them to avoid translation flicker between singular vs plural
        // eslint-disable-next-line @typescript-eslint/no-deprecated
        InteractionManager.runAfterInteractions(() => {
            // Check if we're deleting reports (type:expense-report) or transactions
            if (queryJSON?.type === CONST.SEARCH.DATA_TYPES.EXPENSE_REPORT) {
                // When deleting reports, call deleteAppReport for each unique selected report
                // This will properly unreport the expenses instead of deleting them
                // Get unique report IDs from selected transactions
                const uniqueReportIDs = [...new Set(Object.values(selectedTransactions).map((transaction) => transaction.reportID).filter(Boolean))];
                for (const reportID of uniqueReportIDs) {
                    // Filter transactions for this specific report
                    const reportTransactions = Object.keys(allTransactions ?? {}).reduce<Record<string, Transaction>>((acc, key) => {
                        const transaction = allTransactions?.[key];
                        if (transaction && transaction.reportID === reportID) {
                            acc[key] = transaction;
                        }
                        return acc;
                    }, {});
                    deleteAppReport(reportID, currentUserPersonalDetails?.login ?? '', reportTransactions, allTransactionViolations, bankAccountList);
                }
            } else {
                // When deleting transactions, use the existing flow
                deleteMoneyRequestOnSearch(hash, selectedTransactionsKeys);
            }
            clearSelectedTransactions();
        });
    });
}, [isOffline, showConfirmModal, translate, selectedTransactionsKeys, hash, clearSelectedTransactions, queryJSON?.type, selectedTransactions, currentUserPersonalDetails?.login, allTransactions, allTransactionViolations, bankAccountList]);

App/src/pages/Search/SearchPage.tsx

Lines 429 to 470 in e94f05d

	const handleDeleteSelectedTransactions = useCallback(async () => {
	if (isOffline) {
	setIsOfflineModalVisible(true);
	return;
	}
	if (!hash) {
	return;
	}
	// Use InteractionManager to ensure this runs after the dropdown modal closes
	// eslint-disable-next-line @typescript-eslint/no-deprecated
	InteractionManager.runAfterInteractions(async () => {
	const result = await showConfirmModal({
	title: translate('iou.deleteExpense', {count: selectedTransactionsKeys.length}),
	prompt: translate('iou.deleteConfirmation', {count: selectedTransactionsKeys.length}),
	confirmText: translate('common.delete'),
	cancelText: translate('common.cancel'),
	danger: true,
	});
	if (result.action !== ModalActions.CONFIRM) {
	return;
	}
	// Translations copy for delete modal depends on amount of selected items,
	// We need to wait for modal to fully disappear before clearing them to avoid translation flicker between singular vs plural
	// eslint-disable-next-line @typescript-eslint/no-deprecated
	InteractionManager.runAfterInteractions(() => {
	deleteMoneyRequestOnSearch(hash, selectedTransactionsKeys);
	clearSelectedTransactions();
	});
	});
	}, [isOffline, showConfirmModal, translate, selectedTransactionsKeys, hash, clearSelectedTransactions]);
	const onBulkPaySelected = useCallback(
	(paymentMethod?: PaymentMethodType, additionalData?: Record<string, unknown>) => {
	if (!hash) {
	return;
	}
	if (isOffline) {
	setIsOfflineModalVisible(true);
	return;
	}

3. Update the dependency array to include the new variables used in the conditional logic:
   • queryJSON?.type
   • selectedTransactions (instead of selectedReports)
   • currentUserPersonalDetails?.login
   • allTransactions
   • allTransactionViolations
   • bankAccountList

How this fix works:

• When queryJSON?.type === CONST.SEARCH.DATA_TYPES.EXPENSE_REPORT (user is on the Reports page searching for reports):
  1. Extract unique report IDs from the selected transactions
  2. For each unique report ID, filter the transactions that belong to that report
  3. Call deleteAppReport with the reportID and its filtered transactions
• deleteAppReport handles the proper deletion flow:
  • Deletes the report
  • Sets all transactions back to unreported state
  • Creates appropriate Onyx data updates
• When the query type is not EXPENSE_REPORT (user is on the Expenses page or searching for transactions), the existing deleteMoneyRequestOnSearch flow is used
• This ensures consistent behavior whether deleting a report from search results or from within the report view

Why we filter transactions per report:

The deleteAppReport function expects a reportTransactions parameter of type Record<string, Transaction> containing only the transactions for that specific report. This is necessary because:

• The function uses these transactions to build the optimistic/success/failure data
• It needs to unreport each transaction individually
• Passing all transactions would cause incorrect Onyx updates

What alternative solutions did you explore? (Optional)

Alternative 1: Modify deleteMoneyRequestOnSearch to handle both cases

• Modify the deleteMoneyRequestOnSearch function to accept a parameter indicating whether to unreport or delete
• Rejected because: This would complicate the existing function and require changes to multiple call sites

Alternative 2: Create a new function deleteReportsOnSearch

• Create a new action function specifically for deleting reports from search
• Rejected because: This would duplicate logic that already exists in deleteAppReport

Alternative 3: Update the delete button condition to not show for reports

• Hide the delete option when viewing reports
• Rejected because: This doesn't solve the problem; users should be able to delete reports from search results

Demo

Screen.Recording.2026-01-16.at.4.19.19.AM.mov

[github-actions]

⚠️ @abbasifaizan70 Your proposal is a duplicate of an already existing proposal and has been automatically withdrawn to prevent spam. Please review the existing proposals before submitting a new one.

[annaweber830]

🚫 Duplicated proposal withdrawn by 🤖 ProposalPolice.

[github-actions]

⚠️ @annaweber830 Your proposal is a duplicate of an already existing proposal and has been automatically withdrawn to prevent spam. Please review the existing proposals before submitting a new one.

[nkdengineer]

Proposal

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

The report is deleted and the expenses are deleted.

What is the root cause of that problem?

We always call DeleteMoneyRequestOnSearch, although we select a report with type:expense-report query

App/src/pages/Search/SearchPage.tsx

Lines 455 to 457 in e94f05d

	InteractionManager.runAfterInteractions(() => {
	deleteMoneyRequestOnSearch(hash, selectedTransactionsKeys);
	clearSelectedTransactions();

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

If it's expected that we should delete the app report, we should change two things

1. Update shouldShowDeleteOption to group selected transactions by reportID and check canDeleteMoneyRequestReport with the list transaction of the report. This change is necessary to delete the report with company card transactions. Currently, the Delete option isn't shown for the report card transaction on search page while it's shown on the report secondary action. The reason is that we're checking for each transaction, which canDeleteMoneyRequestReport returns false for a single card transaction list

Screen.Recording.2026-01-16.at.18.20.28.mov

const isExpenseReportType = queryJSON?.type === CONST.SEARCH.DATA_TYPES.EXPENSE_REPORT;
        const canAllSelectedItemsBeDeleted = isExpenseReportType ? selectedReportIDs.every((reportID) => {
            const report = currentSearchResults?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${reportID}`];
            if (!report) {
                return false;
            }
            const transactionIDs = selectedTransactionsKeys.filter((id) => selectedTransactions[id].reportID === reportID);
            const transactions = transactionIDs.map((id) => currentSearchResults?.data?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${id}`]);
            const parentReportActions = transactionIDs.map((id) => {
                const reportActions = currentSearchResults?.data?.[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`];
                return Object.values(reportActions ?? {}).find(
                        (action) => (isMoneyRequestAction(action) ? getOriginalMessage(action)?.IOUTransactionID : undefined) === id,
                    ) ?? selectedTransactions[id].reportAction;
            }).filter((action): action is ReportAction => !!action);
            return canDeleteMoneyRequestReport(report, transactions, parentReportActions);
        }) : selectedTransactionsKeys.every((id) => {
            const transaction = currentSearchResults?.data?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${id}`];
            if (!transaction) {
                return false;
            }
            const parentReportID = transaction.reportID;
            const parentReport = currentSearchResults?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${parentReportID}`];
            const reportActions = currentSearchResults?.data?.[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReportID}`];
            const parentReportAction =
                Object.values(reportActions ?? {}).find(
                    (action) => (isMoneyRequestAction(action) ? getOriginalMessage(action)?.IOUTransactionID : undefined) === transaction.transactionID,
                ) ?? selectedTransactions[id].reportAction;
            return canDeleteMoneyRequestReport(parentReport, [transaction], parentReportAction ? [parentReportAction] : []);
        });

        const shouldShowDeleteOption = !isOffline && canAllSelectedItemsBeDeleted;

App/src/pages/Search/SearchPage.tsx

Lines 923 to 945 in e94f05d

	const shouldShowDeleteOption =
	!isOffline &&
	selectedTransactionsKeys.every((id) => {
	const transaction = currentSearchResults?.data?.[`${ONYXKEYS.COLLECTION.TRANSACTION}${id}`];
	if (!transaction) {
	return false;
	}
	const parentReportID = transaction.reportID;
	const parentReport = currentSearchResults?.data?.[`${ONYXKEYS.COLLECTION.REPORT}${parentReportID}`];
	const reportActions = currentSearchResults?.data?.[`${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${parentReportID}`];
	const parentReportAction =
	Object.values(reportActions ?? {}).find(
	(action) => (isMoneyRequestAction(action) ? getOriginalMessage(action)?.IOUTransactionID : undefined) === transaction.transactionID,
	) ?? selectedTransactions[id].reportAction;
	return canDeleteMoneyRequestReport(parentReport, [transaction], parentReportAction ? [parentReportAction] : []);
	});
	if (shouldShowDeleteOption) {
	options.push({
	icon: expensifyIcons.Trashcan,
	text: translate('search.bulkActions.delete'),
	value: CONST.SEARCH.BULK_ACTION_TYPES.DELETE,
	shouldCloseModalOnSelect: true,

2. Call deleteAppReport here for type:expense-report query

const isExpenseReportType = queryJSON?.type === CONST.SEARCH.DATA_TYPES.EXPENSE_REPORT;
           InteractionManager.runAfterInteractions(() => {
               if (isExpenseReportType) {
                   for (const reportID of selectedReportIDs) {
                       deleteAppReport(reportID, currentUserPersonalDetails?.login ?? '', allTransactions ?? {}, allTransactionViolations, bankAccountList);
                   }
               } else {
                   deleteMoneyRequestOnSearch(hash, selectedTransactionsKeys);
               }
               clearSelectedTransactions();
           });

App/src/pages/Search/SearchPage.tsx

Lines 455 to 457 in e94f05d

	InteractionManager.runAfterInteractions(() => {
	deleteMoneyRequestOnSearch(hash, selectedTransactionsKeys);
	clearSelectedTransactions();

What alternative solutions did you explore? (Optional)

Reminder: Please use plain English, be brief and avoid jargon. Feel free to use images, charts or pseudo-code if necessary. Do not post large multi-line diffs or write walls of text. Do not create PRs unless you have been hired for this job.

[mountiny]

@daledah I think your proposal makes sense