Merge pull request Expensify#67417 from callstack-internal/perf/recomputeDerivedValue-performance-improvements

Author: mountiny

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

@@ -51,37 +51,41 @@ export default createOnyxDerivedValueConfig({
             isFullyComputed = false;
         }
 
+        // if we already computed the report attributes and there is no new reports data, return the current value
+        if ((isFullyComputed && !sourceValues) || !reports) {
+            return currentValue ?? {reports: {}, locale: null};
+        }
+
         const reportUpdates = sourceValues?.[ONYXKEYS.COLLECTION.REPORT] ?? {};
         const reportMetadataUpdates = sourceValues?.[ONYXKEYS.COLLECTION.REPORT_METADATA] ?? {};
         const reportActionsUpdates = sourceValues?.[ONYXKEYS.COLLECTION.REPORT_ACTIONS] ?? {};
         const reportNameValuePairsUpdates = sourceValues?.[ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS] ?? {};
         const transactionsUpdates = sourceValues?.[ONYXKEYS.COLLECTION.TRANSACTION];
         const transactionViolationsUpdates = sourceValues?.[ONYXKEYS.COLLECTION.TRANSACTION_VIOLATIONS];
-        // if we already computed the report attributes and there is no new reports data, return the current value
-        if ((isFullyComputed && !sourceValues) || !reports) {
-            return currentValue ?? {reports: {}, locale: null};
-        }
 
         let dataToIterate = Object.keys(reports);
         // check if there are any report-related updates
 
-        const reportUpdatesRelatedToReportActions: string[] = [];
+        const reportUpdatesRelatedToReportActions = new Set<string>();
+
+        for (const actions of Object.values(reportActionsUpdates)) {
+            if (!actions) {
+                continue;
+            }
 
-        Object.keys(reportActionsUpdates).forEach((reportKey) => {
-            Object.keys(reportActionsUpdates[reportKey] ?? {}).forEach((reportActionKey) => {
-                const reportAction = reportActions?.[reportKey]?.[reportActionKey];
+            for (const reportAction of Object.values(actions)) {
                 if (reportAction?.childReportID) {
-                    reportUpdatesRelatedToReportActions.push(`${ONYXKEYS.COLLECTION.REPORT}${reportAction.childReportID}`);
+                    reportUpdatesRelatedToReportActions.add(`${ONYXKEYS.COLLECTION.REPORT}${reportAction.childReportID}`);
                 }
-            });
-        });
+            }
+        }
 
         const updates = [
             ...Object.keys(reportUpdates),
             ...Object.keys(reportMetadataUpdates),
             ...Object.keys(reportActionsUpdates),
             ...Object.keys(reportNameValuePairsUpdates),
-            ...reportUpdatesRelatedToReportActions,
+            ...Array.from(reportUpdatesRelatedToReportActions),
         ];
 
         if (isFullyComputed) {

src/libs/actions/OnyxDerived/index.ts

@@ -64,24 +64,23 @@ function init() {
                 }
             };
 
+            // Create context once outside the function, swap values inline to avoid overhead of creating new objects frequently
+            const context: DerivedValueContext<typeof key, typeof dependencies> = {
+                currentValue: undefined,
+                sourceValues: undefined,
+                areAllConnectionsSet: false,
+            };
+
             const recomputeDerivedValue = (sourceKey?: string, sourceValue?: unknown, triggeredByIndex?: number) => {
                 // If this recompute was triggered by a connection callback, check if it initializes the connection
                 if (triggeredByIndex !== undefined) {
                     checkAndMarkConnectionInitialized(triggeredByIndex);
                 }
 
-                const context: DerivedValueContext<typeof key, typeof dependencies> = {
-                    currentValue: derivedValue,
-                    sourceValues: undefined,
-                    areAllConnectionsSet,
-                };
+                context.currentValue = derivedValue;
+                context.areAllConnectionsSet = areAllConnectionsSet;
+                context.sourceValues = sourceKey && sourceValue !== undefined ? {[sourceKey]: sourceValue} : undefined;
 
-                // If we got a source key and value, add it to the sourceValues object
-                if (sourceKey && sourceValue !== undefined) {
-                    context.sourceValues = {
-                        [sourceKey]: sourceValue,
-                    };
-                }
                 // @ts-expect-error TypeScript can't confirm the shape of dependencyValues matches the compute function's parameters
                 const newDerivedValue = compute(dependencyValues, context);
                 Log.info(`[OnyxDerived] updating value for ${key} in Onyx`);