Merge pull request #10969 from marmelab/fix-use-get-many-aggregate

Fix `useGetManyAggregate` merge queries with different `meta`

Author: slax57

packages/ra-core/src/dataProvider/useGetManyAggregate.spec.tsx

@@ -1,19 +1,29 @@
 import * as React from 'react';
 import expect from 'expect';
 import { render, waitFor } from '@testing-library/react';
+import { QueryClient } from '@tanstack/react-query';
 
 import { CoreAdminContext } from '../core';
-import { useGetManyAggregate } from './useGetManyAggregate';
+import {
+    useGetManyAggregate,
+    type UseGetManyAggregateOptions,
+} from './useGetManyAggregate';
 import { testDataProvider } from '../dataProvider';
-import { QueryClient } from '@tanstack/react-query';
 
 const UseGetManyAggregate = ({
     resource,
     ids,
+    meta,
     options = {},
     callback = null,
+}: {
+    resource: string;
+    ids: (string | number)[];
+    meta?: any;
+    options?: UseGetManyAggregateOptions;
+    callback?: (v: ReturnType<typeof useGetManyAggregate>) => void;
 }) => {
-    const hookValue = useGetManyAggregate(resource, { ids }, options);
+    const hookValue = useGetManyAggregate(resource, { ids, meta }, options);
     if (callback) callback(hookValue);
     return <div>hello</div>;
 };
@@ -290,6 +300,35 @@ describe('useGetManyAggregate', () => {
             });
         });
     });
+    it('should not aggregate multiple calls for different meta', async () => {
+        render(
+            <CoreAdminContext dataProvider={dataProvider}>
+                <UseGetManyAggregate
+                    resource="posts"
+                    ids={[1, 2]}
+                    meta={{ test: true }}
+                />
+                <UseGetManyAggregate
+                    resource="posts"
+                    ids={[3, 4]}
+                    meta={{ test: true }}
+                />
+                <UseGetManyAggregate resource="posts" ids={[5, 6]} />
+            </CoreAdminContext>
+        );
+        await waitFor(() => {
+            expect(dataProvider.getMany).toHaveBeenCalledTimes(2);
+            expect(dataProvider.getMany).toHaveBeenCalledWith('posts', {
+                ids: [1, 2, 3, 4],
+                meta: { test: true },
+                signal: undefined,
+            });
+            expect(dataProvider.getMany).toHaveBeenCalledWith('posts', {
+                ids: [5, 6],
+                signal: undefined,
+            });
+        });
+    });
 
     it('should deduplicated repeated ids', async () => {
         render(

packages/ra-core/src/dataProvider/useGetManyAggregate.ts

@@ -246,31 +246,37 @@ const callGetManyQueries = batch((calls: GetManyCallArgs[]) => {
     const queryClient = calls[0].queryClient;
 
     /**
-     * Aggregate calls by resource
+     * Aggregate calls by resource and meta
      *
-     * callsByResource will look like:
+     * callsByResourceAndMeta will look like:
      * {
-     *     posts: [{ resource, ids, resolve, reject, dataProvider, queryClient }, ...],
+     *     'posts|{"test":true}': [{ resource, ids, resolve, reject, dataProvider, queryClient }, ...],
+     *     'posts|{"test":false}': [{ resource, ids, resolve, reject, dataProvider, queryClient }, ...],
      *     tags: [{ resource, ids, resolve, reject, dataProvider, queryClient }, ...],
      * }
      */
-    const callsByResource = calls.reduce(
+    const callsByResourceAndMeta = calls.reduce(
         (acc, callArgs) => {
-            if (!acc[callArgs.resource]) {
-                acc[callArgs.resource] = [];
+            const key = `${callArgs.resource}|${JSON.stringify(callArgs.meta)}`;
+            if (!acc[key]) {
+                acc[key] = [];
             }
-            acc[callArgs.resource].push(callArgs);
+            acc[key].push(callArgs);
             return acc;
         },
         {} as { [resource: string]: GetManyCallArgs[] }
     );
 
     /**
-     * For each resource, aggregate ids and call dataProvider.getMany() once
+     * For each resource/meta association, aggregate ids and call dataProvider.getMany() once
      */
-    Object.keys(callsByResource).forEach(resource => {
-        const callsForResource = callsByResource[resource];
+    Object.keys(callsByResourceAndMeta).forEach(resource => {
+        const callsForResource = callsByResourceAndMeta[resource];
 
+        const uniqueResource = callsForResource.reduce(
+            (acc, { resource }) => resource || acc,
+            '' as string // Should never happen as we always have a resource in callArgs but makes TS happy
+        );
         /**
          * Extract ids from queries, aggregate and deduplicate them
          *
@@ -338,7 +344,7 @@ const callGetManyQueries = batch((calls: GetManyCallArgs[]) => {
         queryClient
             .fetchQuery<any[], Error, any[]>({
                 queryKey: [
-                    resource,
+                    uniqueResource,
                     'getMany',
                     {
                         ids: aggregatedIds.map(id => String(id)),
@@ -347,7 +353,7 @@ const callGetManyQueries = batch((calls: GetManyCallArgs[]) => {
                 ],
                 queryFn: queryParams =>
                     dataProvider
-                        .getMany<any>(resource, {
+                        .getMany<any>(uniqueResource, {
                             ids: aggregatedIds,
                             meta: uniqueMeta,
                             signal:
@@ -377,7 +383,7 @@ const callGetManyQueries = batch((calls: GetManyCallArgs[]) => {
 const noop = () => undefined;
 
 export type UseGetManyAggregateOptions<
-    RecordType extends RaRecord,
+    RecordType extends RaRecord = any,
     ErrorType = Error,
 > = Omit<UseQueryOptions<RecordType[], ErrorType>, 'queryKey' | 'queryFn'> & {
     onSuccess?: (data: RecordType[]) => void;