[Due for payment 2026-03-19] [$250] Expense - Card expense can be merged with card expense when imported from CSV file

[nlemma]

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.3.11-17
Reproducible in staging?: Yes
Reproducible in production?: Yes
If this was caught during regression testing, add the test name, ID and link from BrowserStack: #80556
Email or phone of affected tester (no customers): sdjonisjdosjosinjio@gmail.com
Issue reported by: Applause Internal Team
Bug source: Exploratory - Significant User Experience Deterioration
Device used: Mac 26.1 / Chrome
App Component: Money Requests

Action Performed:

Precondition:

• User has imported card transactions from CSV file on OD.

1. Go to staging.new.expensify.com
2. Do not go to Reports tab first.
3. Go to self DM.
4. Open any imported card transaction from CSV file.
5. Click More > Merge.
6. Select any imported card transaction > Continue.
   → Amount section is shown in Select details page.
7. Close the RHP.
8. Go to Reports > Expenses
9. Go back to Inbox and open self DM.
10. Open any imported card transaction from CSV file.
11. Click More > Merge.
12. Select any imported card transaction > Continue.
    → Amount section is not shown in Select details page after opening Reports.

Expected Result:

In Step 5, when card transactions are imported from CSV file, card expenses should not appear in Merge expenses list when merging card expense (we cannot merge card expense with card expense when the expenses are imported from direct feed).

Actual Result:

In Step 5, when card transactions are imported from CSV file, card expenses are shown in Merge expenses list when merging card expense.

In Step 6, when Reports tab is not opened, Amount section is shown in Select details page when merging with card expense.

In Step 12, after opening Reports tab, Amount section is not shown in Select details page when merging with card expense.

Workaround:

Unknown

Platforms:

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

Screenshots/Videos

Bug7063623_1769962726325.29.mp4

View all open jobs on GitHub

Issue Owner

Current Issue Owner: @mallenexpensify

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022021253281022101704
• Upwork Job ID: 2021253281022101704
• Last Price Increase: 2026-02-10
• Automatic offers:
• linhvovan29546 | Contributor | 110435362

[samranahm]

Proposal

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

When card transactions are imported from CSV (e.g. on OldDot), merging a card expense in NewDot incorrectly shows other card expenses in the Merge expenses list. Card expenses should not be mergeable with card expenses (from direct feed or CSV import). Additionally, the Amount section on the Select details page appears when Reports was not opened first but disappears after opening Reports—inconsistent behavior for the same merge flow.

What is the root cause of that problem?

Eligibility for merge is decided by

App/src/libs/MergeTransactionUtils.ts

Lines 368 to 419 in 8372553

	function areTransactionsEligibleForMerge(transaction1: OnyxEntry<Transaction>, transaction2: OnyxEntry<Transaction>) {
	// Both transactions are required
	if (!transaction1 || !transaction2) {
	return false;
	}
	// Do not allow merging transactions that are pending delete
	if (isTransactionPendingDelete(transaction1) || isTransactionPendingDelete(transaction2)) {
	return false;
	}
	if (isScanning(transaction1) || isScanning(transaction2)) {
	return false;
	}
	if (isFetchingWaypointsFromServer(transaction1) || isFetchingWaypointsFromServer(transaction2)) {
	return false;
	}
	// Do not allow merging two card transactions
	if (isFromCreditCardImport(transaction1) && isFromCreditCardImport(transaction2)) {
	return false;
	}
	// Do not allow merging two split expenses
	if (isExpenseSplit(transaction1) && isExpenseSplit(transaction2)) {
	return false;
	}
	// Do not allow merging two $0 transactions
	if (getAmount(transaction1, false, false) === 0 && getAmount(transaction2, false, false) === 0) {
	return false;
	}
	// Do not allow merging a per diem and a card transaction
	if ((isPerDiemRequest(transaction1) && isFromCreditCardImport(transaction2)) || (isPerDiemRequest(transaction2) && isFromCreditCardImport(transaction1))) {
	return false;
	}
	if (isIOUReport(transaction1?.reportID) || isIOUReport(transaction2?.reportID)) {
	return false;
	}
	if (isDistanceRequest(transaction1) !== isDistanceRequest(transaction2)) {
	return false;
	}
	if (isTimeRequest(transaction1) !== isTimeRequest(transaction2)) {
	return false;
	}
	return true;

, which explicitly blocks merging two card transactions at

App/src/libs/MergeTransactionUtils.ts

Lines 386 to 389 in 8372553

	// Do not allow merging two card transactions
	if (isFromCreditCardImport(transaction1) && isFromCreditCardImport(transaction2)) {
	return false;

using isFromCreditCardImport(transaction1) && isFromCreditCardImport(transaction2).

isFromCreditCardImport in TransactionUtils (

App/src/libs/TransactionUtils/index.ts

Lines 1385 to 1413 in 8372553

	// This can be set in transactions found in the search snapshot
	if (transaction?.transactionType === CONST.SEARCH.TRANSACTION_TYPE.CARD) {
	return true;
	}
	if (transaction?.bank === CONST.COMPANY_CARDS.BANK_NAME.UPLOAD) {
	return false;
	}
	if (transaction?.cardName === CONST.EXPENSE.TYPE.CASH_CARD_NAME) {
	return false;
	}
	if (isManagedCardTransaction(transaction)) {
	return true;
	}
	if (transaction?.cardNumber) {
	return true;
	}
	if (transaction?.bank) {
	return true;
	}
	return false;
	}
	function getCardName(transaction: OnyxEntry<Transaction>): string {

) returns false when transaction?.bank === CONST.COMPANY_CARDS.BANK_NAME.UPLOAD (

App/src/libs/TransactionUtils/index.ts

Lines 1392 to 1394 in 8372553

	}
	if (transaction?.cardName === CONST.EXPENSE.TYPE.CASH_CARD_NAME) {

). CSV-imported card transactions can have bank === 'upload', so they are treated as not from credit card import. Two such transactions both get isFromCreditCardImport === false, so the “do not merge two card transactions” check never runs and they appear as eligible. Root cause: CSV-imported card transactions are excluded from “credit card import” when bank === UPLOAD, so they are not blocked from merging with each other. The Amount section inconsistency follows from the same logic: when the target is not considered a card, amount is added to conflict fields and shown; when it is (e.g. after opening Reports and different data), amount is auto-resolved and hidden.

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

Treat CSV-imported card transactions as “from credit card import” for merge eligibility. When bank === UPLOAD, do not always return false; instead, treat the transaction as card import when its type is card (e.g. it has a card name from CSV). Use getTransactionType (

App/src/libs/TransactionUtils/index.ts

Lines 366 to 393 in 8372553

	return CONST.SEARCH.TRANSACTION_TYPE.DISTANCE;
	}
	if (isPerDiemRequest(transaction)) {
	return CONST.SEARCH.TRANSACTION_TYPE.PER_DIEM;
	}
	if (isTimeRequest(transaction)) {
	return CONST.SEARCH.TRANSACTION_TYPE.TIME;
	}
	if (isManagedCardTransaction(transaction)) {
	return CONST.SEARCH.TRANSACTION_TYPE.CARD;
	}
	const cardID = transaction?.cardID;
	if (cardID && cardList?.[cardID]?.cardName === CONST.COMPANY_CARDS.CARD_NAME.CASH) {
	return CONST.SEARCH.TRANSACTION_TYPE.CASH;
	}
	if (!transaction?.cardName || transaction?.cardName?.includes(CONST.EXPENSE.TYPE.CASH_CARD_NAME)) {
	return CONST.SEARCH.TRANSACTION_TYPE.CASH;
	}
	return CONST.SEARCH.TRANSACTION_TYPE.CARD;
	}
	/**

) (which does not depend on isFromCreditCardImport) to decide.

isFromCreditCardImport, when transaction?.bank === CONST.COMPANY_CARDS.BANK_NAME.UPLOAD, return whether the transaction is a card type (so CSV-imported cards are still considered card for merge; manual cash uploads are not).

     if (transaction?.bank === CONST.COMPANY_CARDS.BANK_NAME.UPLOAD) {
-        return false;
+        return getTransactionType(transaction) === CONST.SEARCH.TRANSACTION_TYPE.CARD;
     }

This way when two CSV-imported card expenses both get isFromCreditCardImport === true, so areTransactionsEligibleForMerge returns false and they no longer appear in the merge list. Amount section behavior for card targets (auto-resolve, not shown) becomes consistent.

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.

[cosmicvulpes]

Proposal

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

When merging card transactions imported via CSV file, the behavior is inconsistent:

1. Card expenses appear in the merge list when they shouldn't (CSV-imported card expenses should not be mergeable with each other)
2. The "Amount" section visibility changes based on whether the user has opened the Reports tab before attempting to merge

What is the root cause of that problem?

The root cause is in the isFromCreditCardImport function in src/libs/TransactionUtils/index.ts. This function has an early return based on transactionType:

function isFromCreditCardImport(transaction: OnyxEntry<Transaction>): boolean {
    // This can be set in transactions found in the search snapshot
    if (transaction?.transactionType === CONST.SEARCH.TRANSACTION_TYPE.CARD) {
        return true;
    }
    // ... other checks
}

The transactionType field is populated by the backend for transactions in search results (snapshot), but is NOT present on transactions in the main Onyx TRANSACTION collection.

The inconsistency occurs because:

1. When the user navigates directly to self DM without opening Reports tab, the transaction data comes from the main Onyx collection, which lacks transactionType. The function then falls through to check bank, cardNumber, managedCard properties.

2. When the user opens the Reports/Expenses tab first, the search API is called which populates the search snapshot with transactions that include transactionType: 'card'. This data then gets merged into the main collection via openReport's optimistic data push at Report/index.ts:L1196-1200.

3. For CSV-imported transactions, bank is set to 'upload' and there's an early exit at TransactionUtils:L1391-1393 which correctly returns false for CSV uploads. However, if transactionType === 'card' is set (from search snapshot), it returns true before reaching the bank === 'upload' check.

Impact on merge flow:

• In getMergeableDataAndConflictFields, the amount field handling at MergeTransactionUtils:L224 auto-selects the card transaction's amount when isFromCreditCardImport(targetTransaction) is true, skipping the conflict detection
• In areTransactionsEligibleForMerge, at MergeTransactionUtils:L388, when both transactions are detected as card imports, they are correctly blocked from merging. But CSV imports get incorrectly identified based on stale transactionType data.

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

In isFromCreditCardImport function, move the bank === CONST.COMPANY_CARDS.BANK_NAME.UPLOAD check before the transactionType check. This ensures CSV uploads are always correctly identified regardless of whether transactionType is populated from search results.

function isFromCreditCardImport(transaction: OnyxEntry<Transaction>): boolean {
    // CSV uploads should never be considered as credit card imports
    // Check this first before transactionType to handle snapshot data correctly
    if (transaction?.bank === CONST.COMPANY_CARDS.BANK_NAME.UPLOAD) {
        return false;
    }

    // This can be set in transactions found in the search snapshot
    if (transaction?.transactionType === CONST.SEARCH.TRANSACTION_TYPE.CARD) {
        return true;
    }
    // ... rest of the function unchanged
}

This ensures that:

1. CSV-imported transactions are never classified as credit card imports
2. Two CSV-imported transactions can be merged correctly (they won't fail the areTransactionsEligibleForMerge check)
3. The Amount section will correctly detect conflicts between CSV transactions since they won't trigger the auto-select logic for card transactions

What alternative solutions did you explore? (Optional)

1. Strip transactionType when merging search data into Onyx - This would require modifying the openReport action to filter out transactionType when adding transaction data. However, this could break other functionality that relies on transactionType being present.

2. Clear transactionType for CSV uploads at API level - This would require backend changes which is more invasive.

[dylanexpensify]

reviewing and moving now

[melvin-bot]

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

[melvin-bot]

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