[HOLD for onyx version bump] fix: prevent empty expense report when category is disabled from another tab

src/libs/actions/OnyxDerived/configs/reportTransactionsAndViolations.ts

@@ -8,31 +8,44 @@ import type {OnyxCollection} from 'react-native-onyx';
 let previousViolations: OnyxCollection<TransactionViolation[]> = {};
 const transactionReportIDMapping: Record<string, string> = {};
 
-const transactionToReportIDMap: Record<string, string> = {};
+const getTransactionKeyFromViolationKey = (violationKey: string) => violationKey.replace(ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS, ONYXKEYS.COLLECTION.TRANSACTION);
 
 export default createOnyxDerivedValueConfig({
     key: ONYXKEYS.DERIVED.REPORT_TRANSACTIONS_AND_VIOLATIONS,
     dependencies: [ONYXKEYS.COLLECTION.TRANSACTION, ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS],
-    compute: ([transactions, violations], {sourceValues, currentValue}) => {
-        if (!transactions) {
-            return {};
-        }
+    compute: ([transactions, violations], context) => {
+        const {sourceValues, currentValue} = context;
 
         // If there is a source value for transactions or transaction violations, we need to process only the transactions that have been updated or added
         // If not, we need to process all transactions
         const transactionsUpdates = sourceValues?.[ONYXKEYS.COLLECTION.TRANSACTION];
         const transactionViolationsUpdates = sourceValues?.[ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS];
+        const isPartialUpdate = !!transactionsUpdates || !!transactionViolationsUpdates;
+        // Full recomputes should rebuild from the transaction source so stale derived buckets or deleted transactions are not carried forward.
+        // Partial updates still start from currentValue so violation-only refreshes can preserve report membership when this tab has an incomplete transaction snapshot.
+        const reportTransactionsAndViolations = isPartialUpdate && currentValue ? {...currentValue} : {};
+
+        if (context.isInitialDependencyLoad && currentValue) {
+            previousViolations = violations;
+            context.shouldSkipUpdate = true;
+            return currentValue;
+        }
+
+        if (!transactions) {
+            if (transactionViolationsUpdates) {
+                context.shouldSkipUpdate = true;
+                return reportTransactionsAndViolations;
+            }
+            return {};
+        }
+
         let transactionsToProcess = Object.keys(transactions);
         if (transactionsUpdates) {
             transactionsToProcess = Object.keys(transactionsUpdates);
         } else if (transactionViolationsUpdates) {
-            transactionsToProcess = Object.keys(transactionViolationsUpdates).map((transactionViolation) =>
-                transactionViolation.replace(ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS, ONYXKEYS.COLLECTION.TRANSACTION),
-            );
+            transactionsToProcess = Object.keys(transactionViolationsUpdates).map(getTransactionKeyFromViolationKey);
         }
 
-        const reportTransactionsAndViolations = currentValue ? {...currentValue} : {};
-
         // Track which reportID entries have been cloned so we only clone once per reportID.
         // This avoids mutating nested objects that are still referenced by the cached value.
         const clonedReportIDs = new Set<string>();
@@ -48,28 +61,67 @@ export default createOnyxDerivedValueConfig({
             clonedReportIDs.add(id);
         };
 
+        const getPreviousReportID = (transactionKey: string) =>
+            transactionReportIDMapping[transactionKey] ??
+            Object.keys(reportTransactionsAndViolations).find((reportID) => !!reportTransactionsAndViolations[reportID].transactions[transactionKey]);
+
+        // Empty buckets carry no derived data and can make deleted reports appear again.
+        const deleteReportIfEmpty = (reportID: string | undefined) => {
+            if (!reportID || !reportTransactionsAndViolations[reportID]) {
+                return;
+            }
+
+            if (Object.keys(reportTransactionsAndViolations[reportID].transactions).length > 0 || Object.keys(reportTransactionsAndViolations[reportID].violations).length > 0) {
+                return;
+            }
+
+            delete reportTransactionsAndViolations[reportID];
+            clonedReportIDs.delete(reportID);
+        };
+
+        if (!isPartialUpdate) {
+            for (const transactionKey of Object.keys(transactionReportIDMapping)) {
+                delete transactionReportIDMapping[transactionKey];
+            }
+        } else {
+            for (const reportID of Object.keys(reportTransactionsAndViolations)) {
+                deleteReportIfEmpty(reportID);
+            }
+        }
+
+        if (!transactionsUpdates && transactionViolationsUpdates) {
+            transactionsToProcess = transactionsToProcess.filter((transactionKey) => {
+                return !!transactions[transactionKey];
+            });
+
+            if (transactionsToProcess.length === 0) {
+                context.shouldSkipUpdate = true;
+                return reportTransactionsAndViolations;
+            }
+        }
+
         for (const transactionKey of transactionsToProcess) {
+            // If the reportID of the transaction has changed (e.g. the transaction was split into multiple reports), we need to delete the transaction from the previous reportID and the violations from the previous reportID
+            const previousReportID = getPreviousReportID(transactionKey);
+            const transactionWasUpdated = !!transactionsUpdates;
             const transaction = transactions[transactionKey];
             const reportID = transaction?.reportID;
 
-            // If the reportID of the transaction has changed (e.g. the transaction was split into multiple reports), we need to delete the transaction from the previous reportID and the violations from the previous reportID
-            const previousReportID = transactionReportIDMapping[transactionKey];
-
-            if (previousReportID && previousReportID !== reportID && reportTransactionsAndViolations[previousReportID]) {
+            if (transactionWasUpdated && previousReportID && previousReportID !== reportID && reportTransactionsAndViolations[previousReportID]) {
                 ensureCloned(previousReportID);
                 delete reportTransactionsAndViolations[previousReportID].transactions[transactionKey];
                 const transactionID = transactionKey.replace(ONYXKEYS.COLLECTION.TRANSACTION, '');
                 if (transactionID) {
                     delete reportTransactionsAndViolations[previousReportID].violations[`${ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS}${transactionID}`];
                 }
+                deleteReportIfEmpty(previousReportID);
             }
 
-            if (!transaction && transactionReportIDMapping[transactionKey]) {
+            if (transactionWasUpdated && !transaction && transactionReportIDMapping[transactionKey]) {
                 delete transactionReportIDMapping[transactionKey];
             }
 
             if (!reportID) {
-                delete transactionToReportIDMap[transactionKey];
                 continue;
             }
 
@@ -89,11 +141,12 @@ export default createOnyxDerivedValueConfig({
             const previousTransactionViolations = previousViolations?.[violationKey];
 
             const violationInSourceValues = transactionViolationsUpdates?.[violationKey];
+            const hasExplicitViolationClear = Array.isArray(violationInSourceValues) && violationInSourceValues.length === 0;
 
             // If violations exist and have length > 0, add them to the structure
             if (transactionViolations && transactionViolations.length > 0) {
                 reportTransactionsAndViolations[reportID].violations[violationKey] = transactionViolations;
-            } else if (violationInSourceValues === undefined || (previousTransactionViolations && previousTransactionViolations.length > 0)) {
+            } else if (violationInSourceValues === undefined || hasExplicitViolationClear || (previousTransactionViolations && previousTransactionViolations.length > 0)) {
                 // If violations were removed (previous had violations but current doesn't) or explicitly set to undefined, remove them from the structure
                 delete reportTransactionsAndViolations[reportID].violations[violationKey];
             }
@@ -104,6 +157,10 @@ export default createOnyxDerivedValueConfig({
 
         previousViolations = violations;
 
+        for (const reportID of Object.keys(reportTransactionsAndViolations)) {
+            deleteReportIfEmpty(reportID);
+        }
+
         return reportTransactionsAndViolations;
     },
 });

src/libs/actions/OnyxDerived/index.ts

@@ -39,6 +39,14 @@ function init() {
 
         OnyxUtils.get(key).then((storedDerivedValue) => {
             let derivedValue = storedDerivedValue;
+            let hasSyncedDerivedValueFromOnyx = key !== ONYXKEYS.DERIVED.REPORT_TRANSACTIONS_AND_VIOLATIONS;
+            let pendingRecomputeAfterDerivedValueSync:
+                | {
+                      sourceKey?: string;
+                      sourceValue?: unknown;
+                      triggeredByIndex?: number;
+                  }
+                | undefined;
             if (derivedValue) {
                 Log.info(`Derived value for ${key} restored from disk`);
             }
@@ -80,8 +88,20 @@ function init() {
                     return;
                 }
 
+                if (!hasSyncedDerivedValueFromOnyx) {
+                    pendingRecomputeAfterDerivedValueSync = {
+                        sourceKey,
+                        sourceValue,
+                        triggeredByIndex,
+                    };
+                    Log.info(`[OnyxDerived] waiting for current value sync before recomputing ${key}`);
+                    return;
+                }
+
                 context.currentValue = derivedValue;
                 context.sourceValues = sourceKey && sourceValue !== undefined ? {[sourceKey]: sourceValue} : undefined;
+                context.isInitialDependencyLoad = sourceKey !== undefined && sourceValue === undefined && triggeredByIndex !== undefined;
+                context.shouldSkipUpdate = false;
 
                 const spanId = `${CONST.TELEMETRY.SPAN_ONYX_DERIVED_COMPUTE}_${key}`;
                 startSpan(spanId, {
@@ -94,6 +114,10 @@ function init() {
                 try {
                     // @ts-expect-error TypeScript can't confirm the shape of dependencyValues matches the compute function's parameters
                     const newDerivedValue = compute(dependencyValues, context);
+                    if (context.shouldSkipUpdate) {
+                        Log.info(`[OnyxDerived] skipping update for ${key}`);
+                        return;
+                    }
                     Log.info(`[OnyxDerived] updating value for ${key} in Onyx`);
                     derivedValue = newDerivedValue;
                     setDerivedValue(key, derivedValue);
@@ -102,6 +126,24 @@ function init() {
                 }
             };
 
+            if (key === ONYXKEYS.DERIVED.REPORT_TRANSACTIONS_AND_VIOLATIONS) {
+                Onyx.connectWithoutView({
+                    key,
+                    callback: (value) => {
+                        derivedValue = value;
+                        hasSyncedDerivedValueFromOnyx = true;
+
+                        if (!pendingRecomputeAfterDerivedValueSync) {
+                            return;
+                        }
+
+                        const {sourceKey, sourceValue, triggeredByIndex} = pendingRecomputeAfterDerivedValueSync;
+                        pendingRecomputeAfterDerivedValueSync = undefined;
+                        recomputeDerivedValue(sourceKey, sourceValue, triggeredByIndex);
+                    },
+                });
+            }
+
             for (let i = 0; i < dependencies.length; i++) {
                 const dependencyIndex = i;
                 const dependencyOnyxKey = dependencies[dependencyIndex];

src/libs/actions/OnyxDerived/types.ts

@@ -17,6 +17,8 @@ type DerivedSourceValues<Deps extends readonly OnyxKey[]> = Partial<{
 type DerivedValueContext<Key extends OnyxKey, Deps extends NonEmptyTuple<Exclude<OnyxKey, Key>>> = {
     currentValue?: OnyxValue<Key>;
     sourceValues?: DerivedSourceValues<Deps>;
+    isInitialDependencyLoad?: boolean;
+    shouldSkipUpdate?: boolean;
 };
 
 /**