[Due for payment 2026-01-29] [$250] Report - Report field using reference shows outdated value until refresh

[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.2.47-0
Reproducible in staging?: Y
Reproducible in production?: Y
If this was caught during regression testing, add the test name, ID and link from TestRail: N/A
Email or phone of affected tester (no customers): applausetester+dp376@applause.expensifail.com
Issue reported by: Applause - Internal Team

Action Performed:

1. Create a new report field named “A” (Text) with Initial value set to {field:B}
2. Create a new report field named “B” (Text) with Initial value “value_1”
3. Go to the workspace chat and create a report
4. Observe both report fields display as “value_1”
5. Try changing report field values to new ones

Expected Result:

Both fields (A and B) should display the same updated value

Actual Result:

Field A always shows the previous value of field B until the page is refreshed

Workaround:

Unknown

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
• MacOS: Desktop

Platforms Tested:

On which of our officially supported platforms was this issue tested:

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

Screenshots/Videos

Add any screenshot/video evidence

Bug6997727_1762578717117.9_05_PM_2025-11-07.mp4

View all open jobs on GitHub

Upwork Automation - Do Not Edit

• Upwork Job URL: https://www.upwork.com/jobs/~022011603356840899446
• Upwork Job ID: 2011603356840899446
• Last Price Increase: 2026-01-15

Issue Owner

Current Issue Owner: @

Issue Owner

Current Issue Owner: @mallenexpensify

[melvin-bot]

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

[Burhan-Rashid]

Proposal

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

Report - Report field using reference shows outdated value until refresh

What is the root cause of that problem?

We are only update the current field, we don't check if there is any other report field which depends on the current field and needs to be updated. And also the backend only sends the onyx data of the current field and not for the dependent fields. So only current field gets updated on the UI.

App/src/libs/actions/Report.ts

Lines 2467 to 2479 in 5dc4f0c

	const optimisticData: OnyxUpdate[] = [
	{
	onyxMethod: Onyx.METHOD.MERGE,
	key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
	value: {
	fieldList: {
	[fieldKey]: reportField,
	},
	pendingFields: {
	[fieldKey]: CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE,
	},
	},
	},

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

We need to calculate the dependent fields which needs to be updated based on the current field. we can create a new util function getDependentFieldsToUpdate inside src/libs/ReportUtils.ts for that like this:

function getDependentFieldsToUpdate(reportField: PolicyReportField, report: Report | undefined) {
    if (!report?.fieldList) {
        return {};
    }

    const updatedFields: Record<string, Partial<PolicyReportField>> = {};

    Object.entries(report.fieldList).forEach(([fieldKey, field]) => {
        
        if (field.name === reportField.name) {
            return;
        }

        // Check if it's a formula type and references the current field name
        const expectedDefault = `{field:${reportField.name}}`;
        if (field.type === 'formula' && field.defaultValue === expectedDefault) {
            updatedFields[fieldKey] = {
                ...field,
                value: reportField.value, 
            };
        }
    });

    return updatedFields;
}

And we can call this function here:

App/src/libs/actions/Report.ts

Line 2466 in 5dc4f0c

    const updatedDependentFields = getDependentFieldsToUpdate(reportField, report);

And update the optimistic/success/failure data accordingly here:

App/src/libs/actions/Report.ts

Line 2467 in 5dc4f0c

const optimisticData: OnyxUpdate[] = [

const optimisticData: OnyxUpdate[] = [
        {
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
            value: {
                fieldList: {
                    [fieldKey]: reportField,
                    ...updatedDependentFields,
                },
                pendingFields: {
                    [fieldKey]: CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE,
                    ...Object.fromEntries(Object.keys(updatedDependentFields ?? {}).map((key) => [key, CONST.RED_BRICK_ROAD_PENDING_ACTION.UPDATE])),
                },
            },
        },
        {
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.NEXT_STEP}${reportID}`,
            value: optimisticNextStep,
        },
        {
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
            value: {
                [optimisticChangeFieldAction.reportActionID]: optimisticChangeFieldAction,
            },
        },
    ];
...

 const failureData: OnyxUpdate[] = [
        {
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
            value: {
                fieldList: {
                    [fieldKey]: previousReportField,
                    ...Object.fromEntries(Object.keys(updatedDependentFields ?? {}).map((key) => [key, report.fieldList?.[key]])),
                },
                pendingFields: {
                    [fieldKey]: null,
                    ...Object.fromEntries(Object.keys(updatedDependentFields ?? {}).map((key) => [key, null])),
                },
                errorFields: {
                    [fieldKey]: getMicroSecondOnyxErrorWithTranslationKey('report.genericUpdateReportFieldFailureMessage'),
                    ...Object.fromEntries(
                        Object.keys(updatedDependentFields ?? {}).map((key) => [key, getMicroSecondOnyxErrorWithTranslationKey('report.genericUpdateReportFieldFailureMessage')]),
                    ),
                },
            },
        },
        {
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
            value: {
                [optimisticChangeFieldAction.reportActionID]: {
                    errors: getMicroSecondOnyxErrorWithTranslationKey('report.genericUpdateReportFieldFailureMessage'),
                },
            },
        },
    ];

...
 const successData: OnyxUpdate[] = [
        {
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT}${reportID}`,
            value: {
                pendingFields: {
                    [fieldKey]: null,
                    ...Object.fromEntries(Object.keys(updatedDependentFields ?? {}).map((key) => [key, null])),
                },
                errorFields: {
                    [fieldKey]: null,
                    ...Object.fromEntries(Object.keys(updatedDependentFields ?? {}).map((key) => [key, null])),
                },
            },
        },
        {
            onyxMethod: Onyx.METHOD.MERGE,
            key: `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${reportID}`,
            value: {
                [optimisticChangeFieldAction.reportActionID]: {
                    pendingAction: null,
                },
            },
        },
    ];
...

Note: the new util function code can be discussed with an Internal Engineer and updated according to the logic currently present in the backend. Also things like whether we need to the optimistic/success/failure data for reportActions as well and updation the parameters like reportFields, reportFieldsActionIDs of the API call can be discussed during the PR phase.

App/src/libs/actions/Report.ts

Lines 2577 to 2581 in 5dc4f0c

	const parameters = {
	reportID,
	reportFields: JSON.stringify({[fieldKey]: reportField}),
	reportFieldsActionIDs: JSON.stringify({[fieldKey]: optimisticChangeFieldAction.reportActionID}),
	};

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.

[mukhrr]

🚨 Edited by proposal-police: This proposal was edited at 2026-01-17 11:30:01 UTC.

Proposal

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

When a report field (Field A) references another field (Field B) using a formula like {field:B}, Field A displays stale values when Field B is updated.

What is the root cause of that problem?

The backend computes and stores the resolved value in field.value when the field is created. When field B is updated, field A's stored field.value still contains the old computed result. The frontend displays field.value ?? field.defaultValue directly without re-resolving the {field:X} references from defaultValue.

App/src/components/MoneyRequestReportView/MoneyRequestViewReportFields.tsx

Line 97 in 5dc4f0c

const fieldValue = field.value ?? field.defaultValue;

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

We need a helper util that checks if defaultValue contains {field:X} references and resolves them dynamically using current field values.

/**
 * Get the display value for a report field, resolving any {field:X} references in defaultValue.
 * If defaultValue contains field references, resolves them dynamically using current field values.
 * Otherwise, returns field.value or field.defaultValue as fallback.
 */

function getResolvedFieldValue(
    fieldValue: string | undefined | null,
    defaultValue: string | undefined,
    fieldValuesByName: Record<string, string>,
): string {
    const parts = parse(defaultValue);
    const hasFieldRefs = parts.some((part) => part.type === FORMULA_PART_TYPES.FIELD);

    if (hasFieldRefs) {
        return resolveFieldReferences(defaultValue, fieldValuesByName);
    }

    return fieldValue ?? defaultValue ?? '';
}

And this can be used to compute report field name in MoneyRequestViewReportFields.tsx

const sortedPolicyReportFields = useMemo<EnrichedPolicyReportField[]>((): EnrichedPolicyReportField[] => {
        const fields = getAvailableReportFields(report, Object.values(policy?.fieldList ?? {}));

        const fieldValuesByName: Record<string, string> = {};
        for (const field of fields) {
            const value = field.value ?? field.defaultValue;
            if (field.name && value) {
                fieldValuesByName[field.name.toLowerCase()] = value;
            }
        }

        return fields
            .filter((field) => field.target === report?.type)
            .filter((reportField) => !shouldHideSingleReportField(reportField))
            .sort(({orderWeight: firstOrderWeight}, {orderWeight: secondOrderWeight}) => firstOrderWeight - secondOrderWeight)
            .map((field): EnrichedPolicyReportField => {
                const fieldValue = getResolvedFieldValue(field.value, field.defaultValue, fieldValuesByName);
                const isFieldDisabled = isReportFieldDisabledForUser(report, field, policy);
                
        // existing logic...

And we can similarly update MoneyReportView.tsx too:

App/src/components/ReportActionItem/MoneyReportView.tsx

Lines 92 to 95 in 75c85ae

	const sortedPolicyReportFields = useMemo<PolicyReportField[]>((): PolicyReportField[] => {
	const fields = getAvailableReportFields(report, Object.values(policy?.fieldList ?? {}));
	return fields.filter((field) => field.target === report?.type).sort(({orderWeight: firstOrderWeight}, {orderWeight: secondOrderWeight}) => firstOrderWeight - secondOrderWeight);
	}, [policy?.fieldList, report]);

App/src/components/ReportActionItem/MoneyReportView.tsx

Line 141 in 75c85ae

const fieldValue = reportField.value ?? reportField.defaultValue;

    const {sortedPolicyReportFields, fieldValuesByName} = useMemo(() => {
        const fields = getAvailableReportFields(report, Object.values(policy?.fieldList ?? {}));
        const valuesByName: Record<string, string> = {};
        for (const field of fields) {
            const value = field.value ?? field.defaultValue;
            if (field.name && value) {
                valuesByName[field.name.toLowerCase()] = value;
            }
        }
        const sorted = fields
            .filter((field) => field.target === report?.type)
            .sort(({orderWeight: a}, {orderWeight: b}) => a - b);
        return {sortedPolicyReportFields: sorted, fieldValuesByName: valuesByName};
    }, [policy?.fieldList, report]);

        const fieldValue = getResolvedFieldValue(reportField.value, reportField.defaultValue, fieldValuesByName);

What alternative solutions did you explore? (Optional)

Result:

REC-20251109172135.mp4

[mallenexpensify]

@Burhan-Rashid and @mukhrr , any idea what might be going on here for me? I can't create a a field

2025-11-18_17-03-12.mp4

[mukhrr]

@mallenexpensify BE responses with error now:

"Formula field {field:B} not recognized"

it was not happening when I posted proposal(

[mukhrr]

well I found we send type as "formula" even if we selected "text" to BE and it gives error.

App/src/libs/actions/Policy/ReportField.ts

Lines 178 to 180 in a7d994c

	// User selected type Text but entered a formula Initial value, treat it as a Formula type for optimistic UI
	const shouldTreatTextAsFormula = type === CONST.REPORT_FIELD_TYPES.TEXT && WorkspaceReportFieldUtils.hasFormulaPartsInInitialValue(initialValue);
	const optimisticType = shouldTreatTextAsFormula ? CONST.REPORT_FIELD_TYPES.FORMULA : type;

Adding @ikevin127 to the pool, as he made these changes and may know more info.

[ikevin127]

it was not happening when I posted proposal(

Not sure why the error is happening now, but we added the we send type as "formula" even if we selected "text" FE logic on purpose because BE was already converting the field type from Text to Formula automatically when detecting a formula value on the BE side.

☝️This caused some missing translations and logic issues on the FE side. More details in the issue / pull request comments.

Maybe @neil-marcellini could take a look on the BE side to see why the "Formula field {field:B} not recognized" is happening in this case.