Detect a group export from the child selection metadata, not the group prefix

Ticking a populated group row stores that group's loaded children stamped with
isSelectedViaGroup, not the group key itself. beginExportWithTemplate looked only for
the group prefix, so the card-group case this PR enables took the non-group path: it
sent the loaded transaction IDs and no cardID: filter, exporting incompletely whenever
a group's children were paginated.

Both export paths now share getGroupExportScope so the two detections can't drift
again, and the test fixture stores the child-only shape the provider actually writes,
which reproduces the failure.

Co-authored-by: Yauheni Horbach <ZhenjaHorbach@users.noreply.github.com>

Author: MelvinBot

src/hooks/useSearchBulkActions.ts

@@ -199,6 +199,26 @@ function isGroupSelection(key: string, transaction: SelectedTransactions[string]
     return key.startsWith(CONST.SEARCH.GROUP_PREFIX) || (!!transaction.isSelectedViaGroup && !!transaction.groupKey);
 }
 
+/**
+ * How a selection on a grouped search has to be exported.
+ *
+ * Ticking a populated group row stores that group's loaded children stamped with `isSelectedViaGroup`, not the group
+ * key itself — the group key is only stored when the group had no children loaded. So a group selection has to be
+ * detected with `isGroupSelection` rather than by looking for the group prefix, or a group whose children are
+ * paginated exports only the loaded ones instead of everything the group's filter covers.
+ *
+ * `transactionIDList` drops the rows covered by that filter and keeps the rows the user ticked individually
+ * alongside them.
+ */
+function getGroupExportScope(queryJSON: SearchQueryJSON | undefined, selectedTransactions: SelectedTransactions): {isGroupExport: boolean; transactionIDList: string[]} {
+    const selectedTransactionsKeys = Object.keys(selectedTransactions);
+    const isGroupExport = !!queryJSON?.groupBy && Object.entries(selectedTransactions).some(([key, transaction]) => isGroupSelection(key, transaction));
+    return {
+        isGroupExport,
+        transactionIDList: isGroupExport ? selectedTransactionsKeys.filter((key) => !isGroupSelection(key, selectedTransactions[key])) : selectedTransactionsKeys,
+    };
+}
+
 /**
  * The group rows a selection covers in full.
  *
@@ -958,20 +978,18 @@ function useSearchBulkActions({queryJSON}: UseSearchBulkActionsParams) {
                     true,
                 );
             } else {
-                const isGroupExport = !!queryJSON?.groupBy && selectedTransactionsKeys.some((key) => key.startsWith(CONST.SEARCH.GROUP_PREFIX));
-                // The selected groups travel as a filter on the query, so the group rows themselves are dropped from the ID
-                // list. Rows picked individually alongside those groups are kept, matching how "Current view" exports them.
-                const transactionIDList = isGroupExport ? selectedTransactionsKeys.filter((key) => !isGroupSelection(key, selectedTransactions[key])) : selectedTransactionsKeys;
+                const {isGroupExport, transactionIDList} = getGroupExportScope(queryJSON, selectedTransactions);
                 queueExportSearchWithTemplate(
                     {
                         templateName,
                         templateType,
-                        jsonQuery: isGroupExport
-                            ? serializeQueryJSONForBackend(
-                                  addSelectedGroupsFilter(queryJSON, selectedTransactions, currentSearchResults?.data),
-                                  getGroupExportExactMatchFilterKeys(queryJSON.groupBy),
-                              )
-                            : '{}',
+                        jsonQuery:
+                            isGroupExport && queryJSON
+                                ? serializeQueryJSONForBackend(
+                                      addSelectedGroupsFilter(queryJSON, selectedTransactions, currentSearchResults?.data),
+                                      getGroupExportExactMatchFilterKeys(queryJSON.groupBy),
+                                  )
+                                : '{}',
                         reportIDList: isGroupExport ? [] : selectedTransactionReportIDs,
                         transactionIDList,
                         policyID,
@@ -994,7 +1012,6 @@ function useSearchBulkActions({queryJSON}: UseSearchBulkActionsParams) {
             currentSearchResults?.data,
             queryJSON,
             selectedTransactionReportIDs,
-            selectedTransactionsKeys,
             selectAllMatchingItems,
             clearSelectedTransactions,
         ],
@@ -1106,8 +1123,7 @@ function useSearchBulkActions({queryJSON}: UseSearchBulkActionsParams) {
                 return;
             }
 
-            const isGroupExport = !!queryJSON?.groupBy && Object.entries(selectedTransactions).some(([key, transaction]) => isGroupSelection(key, transaction));
-            const transactionIDList = isGroupExport ? selectedTransactionsKeys.filter((key) => !isGroupSelection(key, selectedTransactions[key])) : selectedTransactionsKeys;
+            const {isGroupExport, transactionIDList} = getGroupExportScope(queryJSON, selectedTransactions);
             let didFail = false;
             const reportIDList = selectedReports.length > 0 ? selectedReportIDs : selectedTransactionReportIDs;
             const queryJSONToExport = isGroupExport && queryJSON ? addSelectedGroupsFilter(queryJSON, selectedTransactions, currentSearchResults?.data) : queryJSON;
@@ -1932,7 +1948,8 @@ function useSearchBulkActions({queryJSON}: UseSearchBulkActionsParams) {
 
             const includeReportLevelExport = ((isExpenseReportType || typeInvoice) && areFullReportsSelected) || (typeExpense && !isExpenseReportType && isAllOneTransactionReport);
 
-            const isGroupedSearch = !!getValidGroupBy(queryJSON?.groupBy);
+            const groupBy = getValidGroupBy(queryJSON?.groupBy);
+            const isGroupedSearch = !!groupBy;
 
             const policy = selectedPolicyIDs.length === 1 ? policies?.[`${ONYXKEYS.COLLECTION.POLICY}${selectedPolicyIDs.at(0)}`] : undefined;
             // The export templates available to the user, pre-grouped and sorted alphabetically. The basic export is part of the default group so it's sorted alongside
@@ -1964,7 +1981,7 @@ function useSearchBulkActions({queryJSON}: UseSearchBulkActionsParams) {
             // which most templates can't be scoped by, so template exports are hidden for it. Reconciliation - All Expenses is
             // the exception on a card-grouped search (Card statements and Card accruals): the selected card groups become a
             // `cardID:` filter, which is exactly the card-spend scope that template reports on.
-            const includesCardGroupExport = includesGroupExport && getValidGroupBy(queryJSON?.groupBy) === CONST.SEARCH.GROUP_BY.CARD;
+            const includesCardGroupExport = includesGroupExport && groupBy === CONST.SEARCH.GROUP_BY.CARD;
             const customTemplatesToShow = includesCardGroupExport ? [] : availableCustomTemplates;
             const defaultTemplatesToShow = includesCardGroupExport
                 ? availableDefaultTemplates.filter((template) => template.templateName === CONST.REPORT.EXPORT_OPTIONS.RECONCILIATION_ALL_EXPENSES)

tests/unit/hooks/useSearchBulkActionsExportTest.ts

@@ -205,7 +205,8 @@ jest.mock('@libs/SearchUIUtils', () => {
         getSelectedGroupFilterEntry: jest.fn(),
         isGroupEntry: (key: string) => key.startsWith(actualCONSTForSearchUIUtils.SEARCH.GROUP_PREFIX),
         navigateToSearchRHP: jest.fn(),
-        getValidGroupBy: jest.fn((groupBy?: string) => groupBy),
+        // The real validator, so the `groupBy === GROUP_BY.CARD` comparison is exercised against it rather than an identity stub.
+        getValidGroupBy: jest.fn(jest.requireActual<{getValidGroupBy: (groupBy?: string) => string | undefined}>('@libs/SearchUIUtils').getValidGroupBy),
         getSearchColumnTranslationKey: jest.fn((column: string) => column),
         getColumnsToShow: jest.fn(() => []),
         insertColumnBeforeTotalAmount: (columns: string[], columnId: string) => {
@@ -1270,14 +1271,24 @@ describe('useSearchBulkActions - export options', () => {
             });
         }
 
-        /** A selection made by ticking a card group's checkbox: the group row plus the child it selected. */
+        /**
+         * A selection made by ticking a populated card group's checkbox. `SearchWriteActionsProvider` stores the
+         * group's loaded children stamped with `groupKey`/`isSelectedViaGroup` and does NOT store the group key
+         * itself — it only stores that when the group had no children loaded (see `selectEmptyCardGroup`).
+         */
         function selectCardGroup() {
             mockSelectedTransactions = {
-                [CARD_GROUP_KEY]: makeSelectedTransaction(),
                 tx1: makeSelectedTransaction({groupKey: CARD_GROUP_KEY, isSelectedViaGroup: true}),
             };
         }
 
+        /** Ticking a card group row whose children were never loaded: the group key is stored on its own. */
+        function selectEmptyCardGroup() {
+            mockSelectedTransactions = {
+                [CARD_GROUP_KEY]: makeSelectedTransaction(),
+            };
+        }
+
         it('offers the Reconciliation template, and only that template, for a card group selection', async () => {
             mockTemplatesIncludingReconciliation();
             selectCardGroup();
@@ -1289,6 +1300,17 @@ describe('useSearchBulkActions - export options', () => {
             });
         });
 
+        it('offers the Reconciliation template for a card group whose children were never loaded', async () => {
+            mockTemplatesIncludingReconciliation();
+            selectEmptyCardGroup();
+
+            const {result} = renderHook(() => useSearchBulkActions({queryJSON: cardGroupedExpenseQueryJSON}), {wrapper: OnyxListItemProvider});
+
+            await waitFor(() => {
+                expect(getExportOptionTexts(result.current.headerButtonsOptions)).toEqual(['export.currentView', 'export.reconciliationAllExpenses']);
+            });
+        });
+
         it('keeps every template hidden when the group selection is grouped by something other than card', async () => {
             mockTemplatesIncludingReconciliation();
             selectCardGroup();
@@ -1311,6 +1333,9 @@ describe('useSearchBulkActions - export options', () => {
             });
         });
 
+        // Regression test for detecting the group export from the child metadata: with only `isSelectedViaGroup`
+        // children selected, looking for the group prefix alone misses the group and exports the loaded IDs instead
+        // of the `cardID:` filter, so a group with paginated children would export incompletely.
         it('scopes the Reconciliation export to the selected card groups instead of a transaction ID list', async () => {
             mockTemplatesIncludingReconciliation();
             selectCardGroup();