Expense rules - Tax rate does not update when expense rule is applied

[lanitochka17]

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: #80915
Email or phone of affected tester (no customers): sdjoidsjosdijoisno@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:

• Workspace taxes are enabled.

1. Go to staging.new.expensify.com
2. Go to Account > Expense rules.
3. Click New rule.
4. Create a rule where Tax will change to 5% rate when Merchant is Apple.
5. Click Save.
6. Go to workspace chat.
7. Create an expense with Apple as merchant.
8. Open the expense report.

Expected Result:

Tax rate will change to 5% as per expense rule.

Actual Result:

Tax rate still remains as 0% and does not change to 5%.

Workaround:

Unknown

Platforms:

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

Screenshots/Videos

Bug7063086_1769885770964.24.mp4

View all open jobs on GitHub

Issue Owner

Current Issue Owner: @QichenZhu

[melvin-bot]

Triggered auto assignment to @sonialiap (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.

[melvin-bot]

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

[MobileMage]

Proposal

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

When a user creates a personal expense rule (under Account > Expense rules) that sets a specific tax rate when the merchant matches a value (e.g., "when merchant is Apple, update tax to 5%"), the tax rate is not applied to expenses created with that merchant. The tax remains at the default rate (0%) instead of changing to the rule-specified rate (5%).

What is the root cause of that problem?

The root cause is that the frontend never applies personal expense rules when the merchant is set on a transaction draft. When the user enters a merchant name on the expense creation flow, setMoneyRequestMerchant is called, which simply writes the merchant to the Onyx draft transaction without checking personal expense rules for a match.

App/src/libs/actions/IOU/index.ts

Lines 1322 to 1324 in 9618ba6

	function setMoneyRequestMerchant(transactionID: string, merchant: string, isDraft: boolean) {
	Onyx.merge(`${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {merchant});
	}

Compare this with setMoneyRequestCategory, which already applies workspace-level category tax rules when the category is set on a draft transaction. After setting the category, it calls getCategoryTaxCodeAndAmount to find the matching workspace expense rule and applies the corresponding tax code and amount to the transaction draft.

App/src/libs/actions/IOU/index.ts

Lines 1353 to 1369 in 9618ba6

	function setMoneyRequestCategory(transactionID: string, category: string, policy: OnyxEntry<OnyxTypes.Policy>, isMovingFromTrackExpense?: boolean) {
	Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`, {category});
	if (isMovingFromTrackExpense) {
	return;
	}
	if (!policy) {
	setMoneyRequestTaxRate(transactionID, '');
	setMoneyRequestTaxAmount(transactionID, null);
	return;
	}
	const transaction = allTransactionDrafts[`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`];
	const {categoryTaxCode, categoryTaxAmount} = getCategoryTaxCodeAndAmount(category, transaction, policy);
	if (categoryTaxCode && categoryTaxAmount !== undefined) {
	setMoneyRequestTaxRate(transactionID, categoryTaxCode);
	setMoneyRequestTaxAmount(transactionID, categoryTaxAmount);
	}
	}

Because setMoneyRequestMerchant does not perform an analogous check against personal expense rules (stored in NVP_EXPENSE_RULES), the transaction draft's taxCode and taxAmount are never updated. When the confirm page reads the tax from the draft, it sees the default tax code and sends that to the backend.

App/src/pages/iou/request/step/IOURequestStepConfirmation.tsx

Lines 265 to 267 in 9618ba6

	const defaultTaxCode = getDefaultTaxCode(policy, transaction);
	const transactionTaxCode = (transaction?.taxCode ? transaction?.taxCode : defaultTaxCode) ?? '';
	const transactionTaxAmount = transaction?.taxAmount ?? 0;

The personal expense rules data is available in Onyx under ONYXKEYS.NVP_EXPENSE_RULES and contains the merchantToMatch field plus the tax field with field_id_TAX.externalID (the tax code) and field_id_TAX.value (the tax percentage), but no code in the expense creation flow ever reads or applies this data.

App/src/types/onyx/ExpenseRule.ts

Lines 1 to 56 in 9618ba6

	/** Model of tax rate on a personal rule */
	type PersonalRuleTaxRate = {
	/** The tax ID */
	externalID: string;
	/** The tax rate */
	value: string;
	};
	/** Model of tax rate on a policy rule */
	type PolicyRuleTaxRate = {
	/** The tax ID */
	externalID: string;
	/** The tax rate */
	value: string;
	/** The name of the tax rate */
	name: string;
	};
	/** Model of expense rule */
	type ExpenseRule = {
	/** Whether the transaction is set to be billable */
	billable?: 'true' | 'false';
	/** The category set by the rule */
	category?: string;
	/** The description set by the rule */
	comment?: string;
	/** Whether to create report if necessary */
	createReport?: boolean;
	/** The merchant set by the rule */
	merchant?: string;
	/** Merchant name to match to apply the rule */
	merchantToMatch: string;
	/** Whether the transaction is set to be reimbursable */
	reimbursable?: 'true' | 'false';
	/** Name of the report to add transactions to */
	report?: string;
	/** The tag set by the rule */
	tag?: string;
	/** The tax rate set by the rule */
	tax?: Record<string, PersonalRuleTaxRate>;
	};
	export type {PersonalRuleTaxRate, PolicyRuleTaxRate};
	export default ExpenseRule;

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

Following the same pattern used by setMoneyRequestCategory for workspace category tax rules, we should enhance setMoneyRequestMerchant to also check personal expense rules and apply the matched rule's tax rate to the transaction draft. The approach is to add an Onyx connection for NVP_EXPENSE_RULES in the IOU index file (alongside the existing connections for transactions, policies, etc.), then extend setMoneyRequestMerchant to match the incoming merchant against the personal expense rules and update the tax fields.

Specifically, in src/libs/actions/IOU/index.ts, add a new Onyx connection to subscribe to personal expense rules near the existing connections (around lines 960-970):

let personalExpenseRules: OnyxEntry<OnyxTypes.ExpenseRule[]> = null;
Onyx.connect({
    key: ONYXKEYS.NVP_EXPENSE_RULES,
    callback: (value) => {
        personalExpenseRules = value ?? null;
    },
});

Then add a helper function to find a matching personal expense rule's tax code based on merchant name, and compute the corresponding tax amount using the existing getTaxValue, calculateTaxAmount, and convertToBackendAmount utilities already used in getCategoryTaxCodeAndAmount:

function getPersonalRuleTaxCodeAndAmount(merchant: string, transactionID: string, policy: OnyxEntry<OnyxTypes.Policy>) {
    if (!personalExpenseRules || !merchant || !policy) {
        return {ruleTaxCode: undefined, ruleTaxAmount: undefined};
    }
    const matchingRule = personalExpenseRules.find(
        (rule) => rule.tax?.field_id_TAX?.externalID && rule.merchantToMatch && merchant.toLowerCase().includes(rule.merchantToMatch.toLowerCase()),
    );
    if (!matchingRule?.tax?.field_id_TAX?.externalID) {
        return {ruleTaxCode: undefined, ruleTaxAmount: undefined};
    }
    const ruleTaxCode = matchingRule.tax.field_id_TAX.externalID;
    const transaction = allTransactionDrafts[`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`];
    const ruleTaxPercentage = getTaxValue(policy, transaction, ruleTaxCode);
    let ruleTaxAmount;
    if (ruleTaxPercentage) {
        ruleTaxAmount = convertToBackendAmount(calculateTaxAmount(ruleTaxPercentage, getAmount(transaction), getCurrency(transaction)));
    }
    return {ruleTaxCode, ruleTaxAmount};
}

Finally, update setMoneyRequestMerchant to accept an optional policy parameter and apply the matched rule's tax (only when setting a draft, matching the category pattern):

function setMoneyRequestMerchant(transactionID: string, merchant: string, isDraft: boolean, policy?: OnyxEntry<OnyxTypes.Policy>) {
    Onyx.merge(`${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {merchant});
    if (isDraft && policy) {
        const {ruleTaxCode, ruleTaxAmount} = getPersonalRuleTaxCodeAndAmount(merchant, transactionID, policy);
        if (ruleTaxCode && ruleTaxAmount !== undefined) {
            setMoneyRequestTaxRate(transactionID, ruleTaxCode);
            setMoneyRequestTaxAmount(transactionID, ruleTaxAmount);
        }
    }
}

The callers in IOURequestStepMerchant.tsx already have access to the policy and can pass it through. The existing call at line 125 would become setMoneyRequestMerchant(transactionID, newMerchant || CONST.TRANSACTION.PARTIAL_TRANSACTION_MERCHANT, !isEditing, policy). Other callers that don't have or need personal rule matching (like distance merchant setting in MoneyRequest.ts) simply omit the optional policy parameter and behavior remains unchanged.

What alternative solutions did you explore? (Optional)

N/A

[annaweber830]

Proposal

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

When a user creates an Expense Rule (Account → Expense rules) that sets a tax rate based on the merchant (e.g., “Apple → 5% tax”), that tax rate is not applied to new expenses with that merchant. The expense continues to show the default tax (0%) instead of the rule-defined tax.

What is the root cause of that problem?

Personal expense rules are stored in Onyx (ONYXKEYS.NVP_EXPENSE_RULES) (e.g. RulePageBase.tsx reads them here:

App/src/pages/settings/Rules/RulePageBase.tsx

Lines 76 to 80 in 7697759

	function RulePageBase({titleKey, testID, hash}: RulePageBaseProps) {
	const {translate} = useLocalize();
	const [expenseRules = getEmptyArray<ExpenseRule>()] = useOnyx(ONYXKEYS.NVP_EXPENSE_RULES, {canBeMissing: true});
	const [form] = useOnyx(ONYXKEYS.FORMS.EXPENSE_RULE_FORM, {canBeMissing: true});
	// Cannot use useRef because react compiler fails

), but the money request draft flow never reads/applies them when the merchant is set.

Specifically, the merchant step calls setMoneyRequestMerchant(...) (

App/src/pages/iou/request/step/IOURequestStepMerchant.tsx

Lines 120 to 126 in 7697759

	if (newMerchant === merchant || (newMerchant === '' && merchant === CONST.TRANSACTION.PARTIAL_TRANSACTION_MERCHANT)) {
	setIsSaved(true);
	shouldNavigateAfterSaveRef.current = true;
	return;
	}
	setMoneyRequestMerchant(transactionID, newMerchant || CONST.TRANSACTION.PARTIAL_TRANSACTION_MERCHANT, !isEditing);
	if (isEditing) {

), and that action only writes the merchant string to the draft transaction and does not attempt to match rules or update taxCode / taxAmount:

App/src/libs/actions/IOU/index.ts

Lines 1320 to 1322 in 7697759

	function setMoneyRequestMerchant(transactionID: string, merchant: string, isDraft: boolean) {
	Onyx.merge(`${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {merchant});
	}

Because the draft never gets a rule-driven taxCode, the confirmation screen falls back to the default tax code/value (resulting in 0%):

App/src/pages/iou/request/step/IOURequestStepConfirmation.tsx

Lines 265 to 267 in 7697759

	const defaultTaxCode = getDefaultTaxCode(policy, transaction);
	const transactionTaxCode = (transaction?.taxCode ? transaction?.taxCode : defaultTaxCode) ?? '';
	const transactionTaxAmount = transaction?.taxAmount ?? 0;

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

Apply personal (Account-level) expense rules during merchant updates for draft transactions, similar to how workspace category tax rules are applied when setting category (see getCategoryTaxCodeAndAmount usage in setMoneyRequestCategory:

App/src/libs/actions/IOU/index.ts

Lines 1351 to 1367 in 7697759

	function setMoneyRequestCategory(transactionID: string, category: string, policy: OnyxEntry<OnyxTypes.Policy>, isMovingFromTrackExpense?: boolean) {
	Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`, {category});
	if (isMovingFromTrackExpense) {
	return;
	}
	if (!policy) {
	setMoneyRequestTaxRate(transactionID, '');
	setMoneyRequestTaxAmount(transactionID, null);
	return;
	}
	const transaction = allTransactionDrafts[`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`];
	const {categoryTaxCode, categoryTaxAmount} = getCategoryTaxCodeAndAmount(category, transaction, policy);
	if (categoryTaxCode && categoryTaxAmount !== undefined) {
	setMoneyRequestTaxRate(transactionID, categoryTaxCode);
	setMoneyRequestTaxAmount(transactionID, categoryTaxAmount);
	}
	}

and the helper itself:

App/src/libs/TransactionUtils/index.ts

Lines 2559 to 2575 in 7697759

	function getCategoryTaxCodeAndAmount(category: string, transaction: OnyxEntry<Transaction>, policy: OnyxEntry<Policy>) {
	const taxRules = policy?.rules?.expenseRules?.filter((rule) => rule.tax);
	if (!taxRules || taxRules?.length === 0 || isDistanceRequest(transaction)) {
	return {categoryTaxCode: undefined, categoryTaxAmount: undefined};
	}
	const defaultTaxCode = getDefaultTaxCode(policy, transaction, getCurrency(transaction));
	const categoryTaxCode = getCategoryDefaultTaxRate(taxRules, category, defaultTaxCode);
	const categoryTaxPercentage = getTaxValue(policy, transaction, categoryTaxCode ?? '');
	let categoryTaxAmount;
	if (categoryTaxPercentage) {
	categoryTaxAmount = convertToBackendAmount(calculateTaxAmount(categoryTaxPercentage, getAmount(transaction), getCurrency(transaction)));
	}
	return {categoryTaxCode, categoryTaxAmount};
	}

).

Concretely:

1. Subscribe to personal expense rules in src/libs/actions/IOU/index.ts (near the other non-UI subscriptions, e.g. around

   App/src/libs/actions/IOU/index.ts

   Lines 963 to 974 in 7697759

   	// Use connectWithoutView because this is created for non-UI task only
   	let recentAttendees: OnyxEntry<Attendee[]>;
   	Onyx.connectWithoutView({
   	key: ONYXKEYS.NVP_RECENT_ATTENDEES,
   	callback: (value) => (recentAttendees = value),
   	});
   	let deprecatedRecentWaypoints: OnyxTypes.RecentWaypoint[] = [];
   	Onyx.connect({
   	key: ONYXKEYS.NVP_RECENT_WAYPOINTS,
   	callback: (val) => (deprecatedRecentWaypoints = val ?? []),
   	});

   ), storing them in a module-level personalExpenseRules variable.
2. Update setMoneyRequestMerchant(...) so that when isDraft === true it:
   • finds a matching personal rule where merchant.toLowerCase().includes(rule.merchantToMatch.toLowerCase())
   • if the rule has a tax (rule.tax.field_id_TAX.externalID + rule.tax.field_id_TAX.value), sets taxCode and recalculates taxAmount for the current draft transaction amount/currency.
3. Add any missing imports in IOU/index.ts needed to calculate the tax amount (e.g., calculateTaxAmount from @libs/TransactionUtils and convertToBackendAmount from @libs/CurrencyUtils).

Change site:

App/src/libs/actions/IOU/index.ts

Lines 1320 to 1322 in 7697759

	function setMoneyRequestMerchant(transactionID: string, merchant: string, isDraft: boolean) {
	Onyx.merge(`${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {merchant});
	}

function setMoneyRequestMerchant(transactionID: string, merchant: string, isDraft: boolean) {
    Onyx.merge(`${isDraft ? ONYXKEYS.COLLECTION.TRANSACTION_DRAFT : ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {merchant});

    if (!isDraft) {
        return;
    }

    const transaction = allTransactionDrafts[`${ONYXKEYS.COLLECTION.TRANSACTION_DRAFT}${transactionID}`];
    if (!transaction || isDistanceRequestTransactionUtils(transaction)) {
        return;
    }

    const matchingRule = personalExpenseRules?.find(
        (rule) => !!rule?.merchantToMatch && merchant.toLowerCase().includes(rule.merchantToMatch.toLowerCase()) && !!rule?.tax?.field_id_TAX?.externalID,
    );
    const taxCode = matchingRule?.tax?.field_id_TAX?.externalID;
    const taxPercentage = matchingRule?.tax?.field_id_TAX?.value;

    if (!taxCode || !taxPercentage) {
        return;
    }

    const taxAmount = convertToBackendAmount(calculateTaxAmount(taxPercentage, getAmount(transaction), getCurrency(transaction)));
    setMoneyRequestTaxRate(transactionID, taxCode);
    setMoneyRequestTaxAmount(transactionID, taxAmount);
}

This ensures that when a user sets the merchant on an expense draft, any matching personal Expense Rule will immediately update the draft’s taxCode/taxAmount, and the confirmation step will display the correct (rule-driven) tax rate instead of falling back to the default.

What alternative solutions did you explore? (Optional)

• Passing expenseRules down from UI (via useOnyx(ONYXKEYS.NVP_EXPENSE_RULES)) into setMoneyRequestMerchant(...) to keep the action more “pure”, but this would require a broader signature change across call sites. Subscribing once inside IOU/index.ts matches existing patterns in that file and keeps the change localized.

[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.