Simplifed query methods/internal tests new lint

eslint.config.js

@@ -44,6 +44,51 @@ export default [
       '@typescript-eslint/no-empty-function': 'off',
       '@typescript-eslint/no-unsafe-function-type': 'off',
       'no-case-declarations': 'off',
+      /**
+       * Disallows direct calls to deprecated imperative query methods of `QueryClient`
+       * for new tests and code
+       *
+       * Existing tests that directly test the methods from before the refactoring
+       * will be grandfathered in and allowed to continue using the deprecated methods.
+       * They should not be removed, but new tests should use the new methods instead.
+       */
+      'no-restricted-syntax': [
+        'error',
+        {
+          selector:
+            'CallExpression[callee.type="MemberExpression"][callee.property.name="fetchQuery"]',
+          message: 'Use queryClient.query(options) instead.',
+        },
+        {
+          selector:
+            'CallExpression[callee.type="MemberExpression"][callee.property.name="prefetchQuery"]',
+          message:
+            'Use queryClient.query(options).catch(noop) instead if errors should be swallowed.',
+        },
+        {
+          selector:
+            'CallExpression[callee.type="MemberExpression"][callee.property.name="ensureQueryData"]',
+          message:
+            "Use queryClient.query({ ...options, staleTime: 'static' }) instead.",
+        },
+        {
+          selector:
+            'CallExpression[callee.type="MemberExpression"][callee.property.name="fetchInfiniteQuery"]',
+          message: 'Use queryClient.infiniteQuery(options) instead.',
+        },
+        {
+          selector:
+            'CallExpression[callee.type="MemberExpression"][callee.property.name="prefetchInfiniteQuery"]',
+          message:
+            'Use queryClient.infiniteQuery(options).catch(noop) instead if errors should be swallowed.',
+        },
+        {
+          selector:
+            'CallExpression[callee.type="MemberExpression"][callee.property.name="ensureInfiniteQueryData"]',
+          message:
+            "Use queryClient.infiniteQuery({ ...options, staleTime: 'static' }) instead.",
+        },
+      ],
       'prefer-const': 'off',
     },
   },

packages/angular-query-experimental/src/__tests__/infinite-query-options.test-d.ts

@@ -72,6 +72,8 @@ describe('infiniteQueryOptions', () => {
       initialPageParam: 1,
     })
 
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     const data = await new QueryClient().fetchInfiniteQuery(options)
 
     expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
@@ -218,14 +220,23 @@ describe('infiniteQueryOptions', () => {
     )
     assertType(
       // @ts-expect-error cannot pass infinite options to non-infinite query functions
+      queryClient.query(options),
+    )
+
+    // deprecated methods below to be removed next major version
+    assertType(
+      // @ts-expect-error cannot pass infinite options to non-infinite query functions
+      // eslint-disable-next-line no-restricted-syntax -- grandfathered direct test
       queryClient.ensureQueryData(options),
     )
     assertType(
       // @ts-expect-error cannot pass infinite options to non-infinite query functions
+      // eslint-disable-next-line no-restricted-syntax -- grandfathered direct test
       queryClient.fetchQuery(options),
     )
     assertType(
       // @ts-expect-error cannot pass infinite options to non-infinite query functions
+      // eslint-disable-next-line no-restricted-syntax -- grandfathered direct test
       queryClient.prefetchQuery(options),
     )
   })

packages/angular-query-experimental/src/__tests__/query-options.test-d.ts

@@ -76,6 +76,8 @@ it('should work when passed to fetchQuery', () => {
     queryFn: () => Promise.resolve(5),
   })
 
+  // grandfathered direct test
+  // eslint-disable-next-line no-restricted-syntax
   const data = new QueryClient().fetchQuery(options)
   assertType<Promise<number>>(data)
 })

packages/preact-query/src/__tests__/infiniteQueryOptions.test-d.tsx

@@ -131,6 +131,8 @@ describe('infiniteQueryOptions', () => {
       initialPageParam: 1,
     })
 
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     const data = await new QueryClient().fetchInfiniteQuery(options)
 
     expectTypeOf(data).toEqualTypeOf<InfiniteData<string, number>>()
@@ -228,14 +230,23 @@ describe('infiniteQueryOptions', () => {
     )
     assertType(
       // @ts-expect-error cannot pass infinite options to non-infinite query functions
+      queryClient.query(options),
+    )
+
+    // deprecated methods below to be removed next major version
+    assertType(
+      // @ts-expect-error cannot pass infinite options to non-infinite query functions
+      // eslint-disable-next-line no-restricted-syntax -- grandfathered direct test
       queryClient.ensureQueryData(options),
     )
     assertType(
       // @ts-expect-error cannot pass infinite options to non-infinite query functions
+      // eslint-disable-next-line no-restricted-syntax -- grandfathered direct test
       queryClient.fetchQuery(options),
     )
     assertType(
       // @ts-expect-error cannot pass infinite options to non-infinite query functions
+      // eslint-disable-next-line no-restricted-syntax -- grandfathered direct test
       queryClient.prefetchQuery(options),
     )
   })

packages/preact-query/src/__tests__/queryOptions.test-d.tsx

@@ -109,6 +109,8 @@ describe('queryOptions', () => {
       queryFn: () => Promise.resolve(5),
     })
 
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     const data = await new QueryClient().fetchQuery(options)
     expectTypeOf(data).toEqualTypeOf<number>()
   })

packages/preact-query/src/__tests__/useInfiniteQuery.test-d.tsx

@@ -31,6 +31,8 @@ describe('pageParam', () => {
 
   it('initialPageParam should define type of param passed to queryFunctionContext for fetchInfiniteQuery', () => {
     const queryClient = new QueryClient()
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     queryClient.fetchInfiniteQuery({
       queryKey: queryKey(),
       queryFn: ({ pageParam }) => {
@@ -54,6 +56,8 @@ describe('pageParam', () => {
 
   it('initialPageParam should define type of param passed to queryFunctionContext for prefetchInfiniteQuery', () => {
     const queryClient = new QueryClient()
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     queryClient.prefetchInfiniteQuery({
       queryKey: queryKey(),
       queryFn: ({ pageParam }) => {

packages/query-codemods/eslint.config.js

@@ -15,4 +15,11 @@ export default [
       'sort-imports': 'off',
     },
   },
+  {
+    files: ['src/**/__testfixtures__/**'],
+    rules: {
+      // Codemod fixtures intentionally preserve historical QueryClient syntax.
+      'no-restricted-syntax': 'off',
+    },
+  },
 ]

packages/query-core/src/__tests__/queryClient.test-d.tsx

@@ -9,12 +9,11 @@ import type {
   DataTag,
   DefaultError,
   DefaultedQueryObserverOptions,
-  EnsureQueryDataOptions,
-  FetchInfiniteQueryOptions,
   InfiniteData,
   InfiniteQueryExecuteOptions,
   MutationOptions,
   OmitKeyof,
+  QueryExecuteOptions,
   QueryKey,
   QueryObserverOptions,
 } from '../types'
@@ -193,6 +192,8 @@ describe('fetchInfiniteQuery', () => {
   })
 
   it('should allow passing pages', async () => {
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     const data = await new QueryClient().fetchInfiniteQuery({
       queryKey: queryKey(),
       queryFn: () => Promise.resolve('string'),
@@ -349,6 +350,10 @@ describe('fully typed usage', () => {
     // Construct typed arguments
     //
 
+    const queryOptions: QueryExecuteOptions<TData, TError> = {
+      queryKey: ['key', 'query'],
+    }
+
     const infiniteQueryOptions: InfiniteQueryExecuteOptions<
       TData,
       TError,
@@ -363,21 +368,6 @@ describe('fully typed usage', () => {
       initialPageParam: 0,
     }
 
-    const queryOptions: EnsureQueryDataOptions<TData, TError> = {
-      queryKey: ['key', 'query'],
-    }
-
-    const fetchInfiniteQueryOptions: FetchInfiniteQueryOptions<TData, TError> =
-      {
-        queryKey: ['key', 'infinite'],
-        pages: 5,
-        getNextPageParam: (lastPage) => {
-          expectTypeOf(lastPage).toEqualTypeOf<TData>()
-          return 0
-        },
-        initialPageParam: 0,
-      }
-
     const mutationOptions: MutationOptions<TData, TError> = {}
 
     const queryFilters: QueryFilters<DataTag<QueryKey, TData, TError>> = {
@@ -412,6 +402,8 @@ describe('fully typed usage', () => {
     const queryData1 = queryClient.getQueryData(filterKey)
     expectTypeOf(queryData1).toEqualTypeOf<TData | undefined>()
 
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     const queryData2 = await queryClient.ensureQueryData(queryOptions)
     expectTypeOf(queryData2).toEqualTypeOf<TData>()
 
@@ -450,27 +442,33 @@ describe('fully typed usage', () => {
       QueryState<TData, TError> | undefined
     >()
 
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     const fetchedQuery = await queryClient.fetchQuery(queryOptions)
     expectTypeOf(fetchedQuery).toEqualTypeOf<TData>()
 
     const queriedData = await queryClient.query(queryOptions)
     expectTypeOf(queriedData).toEqualTypeOf<TData>()
 
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     queryClient.prefetchQuery(queryOptions)
 
-    const fetchInfiniteQueryResult = await queryClient.fetchInfiniteQuery(
-      fetchInfiniteQueryOptions,
-    )
+    const fetchInfiniteQueryResult =
+      // grandfathered direct test
+      // eslint-disable-next-line no-restricted-syntax
+      await queryClient.fetchInfiniteQuery(infiniteQueryOptions)
     expectTypeOf(fetchInfiniteQueryResult).toEqualTypeOf<
       InfiniteData<TData, unknown>
     >()
 
     const infiniteQuery = await queryClient.infiniteQuery(infiniteQueryOptions)
     expectTypeOf(infiniteQuery).toEqualTypeOf<InfiniteData<TData, unknown>>()
 
-    const infiniteQueryData = await queryClient.ensureInfiniteQueryData(
-      fetchInfiniteQueryOptions,
-    )
+    const infiniteQueryData =
+      // grandfathered direct test
+      // eslint-disable-next-line no-restricted-syntax
+      await queryClient.ensureInfiniteQueryData(infiniteQueryOptions)
     expectTypeOf(infiniteQueryData).toEqualTypeOf<
       InfiniteData<TData, unknown>
     >()
@@ -508,7 +506,9 @@ describe('fully typed usage', () => {
     queryClient.cancelQueries(queryFilters)
     queryClient.invalidateQueries(queryFilters)
     queryClient.refetchQueries(queryFilters)
-    queryClient.prefetchInfiniteQuery(fetchInfiniteQueryOptions)
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
+    queryClient.prefetchInfiniteQuery(infiniteQueryOptions)
     queryClient.setQueryDefaults(filterKey, {} as any)
     queryClient.getMutationDefaults(mutationKey)
   })
@@ -520,10 +520,10 @@ describe('fully typed usage', () => {
     // Construct typed arguments
     //
 
-    const queryOptions: EnsureQueryDataOptions = {
+    const queryOptions: QueryExecuteOptions = {
       queryKey: ['key'] as any,
     }
-    const fetchInfiniteQueryOptions: FetchInfiniteQueryOptions = {
+    const fetchInfiniteQueryOptions: InfiniteQueryExecuteOptions = {
       queryKey: ['key'] as any,
       pages: 5,
       getNextPageParam: (lastPage) => {
@@ -566,6 +566,8 @@ describe('fully typed usage', () => {
     const queryData1 = queryClient.getQueryData(filterKey)
     expectTypeOf(queryData1).toEqualTypeOf<unknown>()
 
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     const queryData2 = await queryClient.ensureQueryData(queryOptions)
     expectTypeOf(queryData2).toEqualTypeOf<unknown>()
 
@@ -597,14 +599,20 @@ describe('fully typed usage', () => {
       QueryState<unknown, DefaultError> | undefined
     >()
 
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     const fetchedQuery = await queryClient.fetchQuery(queryOptions)
     expectTypeOf(fetchedQuery).toEqualTypeOf<unknown>()
 
     const queriedData = await queryClient.query(queryOptions)
     expectTypeOf(queriedData).toEqualTypeOf<unknown>()
 
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     queryClient.prefetchQuery(queryOptions)
 
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     const fetchInfiniteQueryResult = await queryClient.fetchInfiniteQuery(
       fetchInfiniteQueryOptions,
     )
@@ -617,6 +625,8 @@ describe('fully typed usage', () => {
     )
     expectTypeOf(infiniteQuery).toEqualTypeOf<InfiniteData<unknown, unknown>>()
 
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     const infiniteQueryData = await queryClient.ensureInfiniteQueryData(
       fetchInfiniteQueryOptions,
     )
@@ -663,6 +673,8 @@ describe('fully typed usage', () => {
     queryClient.cancelQueries(queryFilters)
     queryClient.invalidateQueries(queryFilters)
     queryClient.refetchQueries(queryFilters)
+    // grandfathered direct test
+    // eslint-disable-next-line no-restricted-syntax
     queryClient.prefetchInfiniteQuery(fetchInfiniteQueryOptions)
     queryClient.setQueryDefaults(filterKey, {} as any)
     queryClient.getMutationDefaults(mutationKey)