fix(types): pass TError, TQueryData and TQueryKey to PlaceholderDataFunction (#6349)

* fix: pass TError, TQueryData and TQueryKey to PlaceholderDataFunction

* test: add types test for placeholderData function

* style: format

---------

Co-authored-by: Benedikt Viebahn <[email protected]>
Co-authored-by: Dominik Dorfmeister <[email protected]>
Co-authored-by: Benedikt Viebahn <[email protected]>

Author: 4 people

packages/query-core/src/tests/queryObserver.types.test.tsx

@@ -0,0 +1,64 @@
+import { describe, it } from 'vitest'
+import { QueryObserver } from '..'
+import { createQueryClient, doNotExecute } from './utils'
+import type { Equal, Expect } from './utils'
+
+describe('placeholderData', () => {
+  describe('placeholderData function', () => {
+    it('previousQuery should have typed queryKey', () => {
+      doNotExecute(() => {
+        const queryKey = ['SomeQuery', 42, { foo: 'bar' }] as const
+        type QueryKey = typeof queryKey
+
+        new QueryObserver(createQueryClient(), {
+          queryKey,
+          placeholderData: (_, previousQuery) => {
+            const previousQueryKey = previousQuery?.queryKey
+
+            const result: Expect<
+              Equal<typeof previousQueryKey, QueryKey | undefined>
+            > = true
+            return result
+          },
+        })
+      })
+    })
+
+    it('previousQuery should have typed error', () => {
+      doNotExecute(() => {
+        class CustomError extends Error {
+          name = 'CustomError' as const
+        }
+
+        new QueryObserver<boolean, CustomError>(createQueryClient(), {
+          placeholderData: (_, previousQuery) => {
+            const error = previousQuery?.state.error
+
+            const result: Expect<
+              Equal<typeof error, CustomError | null | undefined>
+            > = true
+            return result
+          },
+        })
+      })
+    })
+
+    it('previousData should have the same type as query data', () => {
+      doNotExecute(() => {
+        const queryData = { foo: 'bar' } as const
+        type QueryData = typeof queryData
+
+        new QueryObserver(createQueryClient(), {
+          queryFn: () => queryData,
+          select: (data) => data.foo,
+          placeholderData: (previousData) => {
+            const result: Expect<
+              Equal<typeof previousData, QueryData | undefined>
+            > = true
+            return result ? previousData : undefined
+          },
+        })
+      })
+    })
+  })
+})

packages/query-core/src/types.ts

@@ -325,7 +325,12 @@ export interface QueryObserverOptions<
    */
   placeholderData?:
     | NonFunctionGuard<TQueryData>
-    | PlaceholderDataFunction<NonFunctionGuard<TQueryData>>
+    | PlaceholderDataFunction<
+        NonFunctionGuard<TQueryData>,
+        TError,
+        NonFunctionGuard<TQueryData>,
+        TQueryKey
+      >
 
   _optimisticResults?: 'optimistic' | 'isRestoring'
 }