[TypeScript] Fix useGetOne and useGetMany params type when id param is undefined

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

@@ -1,12 +1,12 @@
 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 { useGetMany } from './useGetMany';
+import { useGetOne } from './useGetOne';
 import { testDataProvider } from '../dataProvider';
-import { useState } from 'react';
-import { QueryClient } from '@tanstack/react-query';
 
 const UseGetMany = ({
     resource,
@@ -39,7 +39,7 @@ const UseCustomGetMany = ({
     options?: any;
     callback?: Function;
 }) => {
-    const [stateIds, setStateIds] = useState(ids);
+    const [stateIds, setStateIds] = React.useState(ids);
     const hookValue = useGetMany(resource, { ids: stateIds }, options);
     if (callback) callback(hookValue);
 
@@ -398,4 +398,45 @@ describe('useGetMany', () => {
             expect(abort).toHaveBeenCalled();
         });
     });
+
+    describe('TypeScript', () => {
+        it('should return the parametric type', () => {
+            type Foo = { id: number; name: string };
+            const _Dummy = () => {
+                const { data, error, isPending } = useGetMany<Foo>('posts', {
+                    ids: [1],
+                });
+                if (isPending || error) return null;
+                return <div>{data[0].name}</div>;
+            };
+            // no render needed, only checking types
+        });
+        it('should accept empty id param', () => {
+            const _Dummy = () => {
+                type Post = {
+                    id: number;
+                    tag_ids: number[];
+                };
+                const { data: comment } = useGetOne<Post>('comments', {
+                    id: 1,
+                });
+                type Tag = {
+                    id: number;
+                    name: string;
+                };
+                const { data, error, isPending } = useGetMany<Tag>('posts', {
+                    ids: comment?.tag_ids,
+                });
+                if (isPending || error) return null;
+                return (
+                    <ul>
+                        {data.map(tag => (
+                            <li key={tag.id}>{tag.name}</li>
+                        ))}
+                    </ul>
+                );
+            };
+            // no render needed, only checking types
+        });
+    });
 });

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

@@ -53,7 +53,7 @@ import { useEvent } from '../util';
  */
 export const useGetMany = <RecordType extends RaRecord = any>(
     resource: string,
-    params: Partial<GetManyParams> = {},
+    params: Partial<GetManyParams<RecordType>>,
     options: UseGetManyOptions<RecordType> = {}
 ): UseGetManyHookValue<RecordType> => {
     const { ids, meta } = params;
@@ -64,6 +64,7 @@ export const useGetMany = <RecordType extends RaRecord = any>(
         onError = noop,
         onSuccess = noop,
         onSettled = noop,
+        enabled,
         ...queryOptions
     } = options;
     const onSuccessEvent = useEvent(onSuccess);
@@ -115,6 +116,7 @@ export const useGetMany = <RecordType extends RaRecord = any>(
             }
         },
         retry: false,
+        enabled: enabled ?? ids != null,
         ...queryOptions,
     });
 

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

@@ -68,7 +68,7 @@ import { useEvent } from '../util';
  */
 export const useGetManyAggregate = <RecordType extends RaRecord = any>(
     resource: string,
-    params: GetManyParams,
+    params: Partial<GetManyParams<RecordType>>,
     options: UseGetManyAggregateOptions<RecordType> = {}
 ): UseGetManyHookValue<RecordType> => {
     const dataProvider = useDataProvider();
@@ -78,6 +78,7 @@ export const useGetManyAggregate = <RecordType extends RaRecord = any>(
         onError = noop,
         onSuccess = noop,
         onSettled = noop,
+        enabled,
         ...queryOptions
     } = options;
     const onSuccessEvent = useEvent(onSuccess);
@@ -133,6 +134,7 @@ export const useGetManyAggregate = <RecordType extends RaRecord = any>(
                 });
             }),
         placeholderData,
+        enabled: enabled ?? ids != null,
         retry: false,
         ...queryOptions,
     });

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

@@ -299,4 +299,38 @@ describe('useGetOne', () => {
             expect(abort).toHaveBeenCalled();
         });
     });
+    describe('TypeScript', () => {
+        it('should return the parametric type', () => {
+            type Foo = { id: number; name: string };
+            const _Dummy = () => {
+                const { data, error, isPending } = useGetOne<Foo>('posts', {
+                    id: 1,
+                });
+                if (isPending || error) return null;
+                return <div>{data.name}</div>;
+            };
+            // no render needed, only checking types
+        });
+        it('should accept empty id param', () => {
+            const _Dummy = () => {
+                type Comment = {
+                    id: number;
+                    post_id: number;
+                };
+                const { data: comment } = useGetOne<Comment>('comments', {
+                    id: 1,
+                });
+                type Post = {
+                    id: number;
+                    title: string;
+                };
+                const { data, error, isPending } = useGetOne<Post>('posts', {
+                    id: comment?.post_id,
+                });
+                if (isPending || error) return null;
+                return <div>{data.title}</div>;
+            };
+            // no render needed, only checking types
+        });
+    });
 });

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

@@ -49,14 +49,15 @@ import { useEvent } from '../util';
  */
 export const useGetOne = <RecordType extends RaRecord = any>(
     resource: string,
-    { id, meta }: GetOneParams<RecordType>,
+    { id, meta }: Partial<GetOneParams<RecordType>>,
     options: UseGetOneOptions<RecordType> = {}
 ): UseGetOneHookValue<RecordType> => {
     const dataProvider = useDataProvider();
     const {
         onError = noop,
         onSuccess = noop,
         onSettled = noop,
+        enabled,
         ...queryOptions
     } = options;
     const onSuccessEvent = useEvent(onSuccess);
@@ -69,16 +70,19 @@ export const useGetOne = <RecordType extends RaRecord = any>(
         // As the react-query cache is type-sensitive, we always stringify the identifier to get a match
         queryKey: [resource, 'getOne', { id: String(id), meta }],
         queryFn: queryParams =>
-            dataProvider
-                .getOne<RecordType>(resource, {
-                    id,
-                    meta,
-                    signal:
-                        dataProvider.supportAbortSignal === true
-                            ? queryParams.signal
-                            : undefined,
-                })
-                .then(({ data }) => data),
+            id == null
+                ? new Promise(() => {})
+                : dataProvider
+                      .getOne<RecordType>(resource, {
+                          id,
+                          meta,
+                          signal:
+                              dataProvider.supportAbortSignal === true
+                                  ? queryParams.signal
+                                  : undefined,
+                      })
+                      .then(({ data }) => data),
+        enabled: enabled ?? id != null,
         ...queryOptions,
     });
 

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

@@ -202,7 +202,7 @@ export const withLifecycleCallbacks = (
 
         getMany: async function <RecordType extends RaRecord = any>(
             resource: string,
-            params: GetManyParams
+            params: GetManyParams<RecordType>
         ) {
             let newParams = params;
 

packages/ra-core/src/types.ts

@@ -99,7 +99,7 @@ export type DataProvider<ResourceType extends string = string> = {
 
     getMany: <RecordType extends RaRecord = any>(
         resource: ResourceType,
-        params: GetManyParams & QueryFunctionContext
+        params: GetManyParams<RecordType> & QueryFunctionContext
     ) => Promise<GetManyResult<RecordType>>;
 
     getManyReference: <RecordType extends RaRecord = any>(
@@ -172,8 +172,8 @@ export interface GetOneResult<RecordType extends RaRecord = any> {
     data: RecordType;
 }
 
-export interface GetManyParams {
-    ids: Identifier[];
+export interface GetManyParams<RecordType extends RaRecord = any> {
+    ids: RecordType['id'][];
     meta?: any;
     signal?: AbortSignal;
 }

packages/ra-data-localforage/src/index.ts

@@ -1,6 +1,5 @@
 /* eslint-disable import/no-anonymous-default-export */
 import fakeRestProvider from 'ra-data-fakerest';
-
 import {
     CreateParams,
     DataProvider,
@@ -111,7 +110,7 @@ export default async (
         ) => baseDataProvider.getOne<RecordType>(resource, params),
         getMany: <RecordType extends RaRecord = any>(
             resource: string,
-            params: GetManyParams
+            params: GetManyParams<RecordType>
         ) => baseDataProvider.getMany<RecordType>(resource, params),
         getManyReference: <RecordType extends RaRecord = any>(
             resource: string,