From 254dafc9ec63a2f4da24493403f33e8369cfdb97 Mon Sep 17 00:00:00 2001 From: Egor Mostovoy Date: Fri, 12 Dec 2025 12:28:47 +0100 Subject: [PATCH 1/3] Revert manual disabled (#43) --- .../__tests__/useQueryData.refetch.test.ts | 180 ------------------ src/react-query/impl/infinite/hooks.ts | 6 +- src/react-query/impl/plain/hooks.ts | 6 +- src/react-query/types/options.ts | 5 - src/react-query/utils/warn.ts | 8 - src/react-query/utils/warnDisabledRefetch.ts | 5 - 6 files changed, 2 insertions(+), 208 deletions(-) delete mode 100644 src/react-query/hooks/__tests__/useQueryData.refetch.test.ts delete mode 100644 src/react-query/utils/warn.ts delete mode 100644 src/react-query/utils/warnDisabledRefetch.ts diff --git a/src/react-query/hooks/__tests__/useQueryData.refetch.test.ts b/src/react-query/hooks/__tests__/useQueryData.refetch.test.ts deleted file mode 100644 index 2e9c9eb..0000000 --- a/src/react-query/hooks/__tests__/useQueryData.refetch.test.ts +++ /dev/null @@ -1,180 +0,0 @@ -import {QueryClient, useInfiniteQuery, useQuery} from '@tanstack/react-query'; -import {renderHook} from '@testing-library/react'; - -import {idle} from '../../../core'; -import type {AnyInfiniteQueryDataSource} from '../../impl/infinite/types'; -import type {AnyPlainQueryDataSource} from '../../impl/plain/types'; -import {warnDisabledRefetch} from '../../utils/warnDisabledRefetch'; -import {useQueryContext} from '../useQueryContext'; -import {useQueryData} from '../useQueryData'; - -jest.mock('@tanstack/react-query', () => ({ - ...jest.requireActual('@tanstack/react-query'), - useQuery: jest.fn(), - useInfiniteQuery: jest.fn(), -})); - -jest.mock('../useQueryContext'); -jest.mock('../../utils/warnDisabledRefetch'); - -const mockUseQuery = useQuery as jest.MockedFunction; -const mockUseInfiniteQuery = useInfiniteQuery as jest.MockedFunction; -const mockWarnDisabledRefetch = warnDisabledRefetch as jest.MockedFunction< - typeof warnDisabledRefetch ->; - -describe('useQueryData refetch behavior', () => { - const mockQueryClient = new QueryClient(); - const mockContext = {queryClient: mockQueryClient}; - - beforeEach(() => { - jest.clearAllMocks(); - (useQueryContext as jest.Mock).mockReturnValue(mockContext); - }); - - const createMockQueryResult = (refetch = jest.fn()) => ({ - data: 'test-data', - error: null, - status: 'success' as const, - fetchStatus: 'idle' as const, - isLoading: false, - isError: false, - isSuccess: true, - isPending: false, - refetch, - dataUpdatedAt: Date.now(), - errorUpdatedAt: 0, - failureCount: 0, - failureReason: null, - isFetched: true, - isFetchedAfterMount: true, - isFetching: false, - isInitialLoading: false, - isLoadingError: false, - isPaused: false, - isPlaceholderData: false, - isPreviousData: false, - isRefetchError: false, - isRefetching: false, - isStale: false, - promise: Promise.resolve('test-data'), - }); - - const createMockInfiniteResult = (refetch = jest.fn()) => ({ - data: {pages: [['item1'], ['item2']], pageParams: [undefined, 'next-page']}, - error: null, - status: 'success' as const, - fetchStatus: 'idle' as const, - isLoading: false, - isError: false, - isSuccess: true, - isPending: false, - refetch, - hasNextPage: false, - hasPreviousPage: false, - fetchNextPage: jest.fn(), - fetchPreviousPage: jest.fn(), - isFetchingNextPage: false, - isFetchingPreviousPage: false, - dataUpdatedAt: Date.now(), - errorUpdatedAt: 0, - failureCount: 0, - failureReason: null, - isFetched: true, - isFetchedAfterMount: true, - isFetching: false, - isInitialLoading: false, - isLoadingError: false, - isPaused: false, - isPlaceholderData: false, - isPreviousData: false, - isRefetchError: false, - isRefetching: false, - isStale: false, - promise: Promise.resolve({ - pages: [['item1'], ['item2']], - pageParams: [undefined, 'next-page'], - }), - }); - - describe('plain data source', () => { - const plainDataSource: AnyPlainQueryDataSource = { - type: 'plain', - name: 'test-plain', - fetch: jest.fn().mockResolvedValue({data: 'test-data'}), - }; - - it('should use original refetch when no enabled option', () => { - const originalRefetch = jest.fn(); - mockUseQuery.mockReturnValue(createMockQueryResult(originalRefetch) as any); - - const {result} = renderHook(() => useQueryData(plainDataSource, {id: 1})); - - expect(result.current.refetch).toBe(originalRefetch); - expect(result.current.refetch).not.toBe(mockWarnDisabledRefetch); - }); - - it('should use warnDisabledRefetch when enabled: false', () => { - const originalRefetch = jest.fn(); - mockUseQuery.mockReturnValue(createMockQueryResult(originalRefetch) as any); - - const {result} = renderHook(() => - useQueryData(plainDataSource, {id: 1}, {enabled: false}), - ); - - expect(result.current.refetch).toBe(mockWarnDisabledRefetch); - expect(result.current.refetch).not.toBe(originalRefetch); - }); - - it('should use warnDisabledRefetch when params is idle', () => { - const originalRefetch = jest.fn(); - mockUseQuery.mockReturnValue(createMockQueryResult(originalRefetch) as any); - - const {result} = renderHook(() => useQueryData(plainDataSource, idle)); - - expect(result.current.refetch).toBe(mockWarnDisabledRefetch); - expect(result.current.refetch).not.toBe(originalRefetch); - }); - }); - - describe('infinite data source', () => { - const infiniteDataSource: AnyInfiniteQueryDataSource = { - type: 'infinite', - name: 'test-infinite', - fetch: jest.fn().mockResolvedValue({data: ['item1', 'item2']}), - next: jest.fn(), - }; - - it('should use original refetch when no enabled option', () => { - const originalRefetch = jest.fn(); - mockUseInfiniteQuery.mockReturnValue(createMockInfiniteResult(originalRefetch) as any); - - const {result} = renderHook(() => useQueryData(infiniteDataSource, {id: 1})); - - expect(result.current.refetch).toBe(originalRefetch); - expect(result.current.refetch).not.toBe(mockWarnDisabledRefetch); - }); - - it('should use warnDisabledRefetch when enabled: false', () => { - const originalRefetch = jest.fn(); - mockUseInfiniteQuery.mockReturnValue(createMockInfiniteResult(originalRefetch) as any); - - const {result} = renderHook(() => - useQueryData(infiniteDataSource, {id: 1}, {enabled: false}), - ); - - expect(result.current.refetch).toBe(mockWarnDisabledRefetch); - expect(result.current.refetch).not.toBe(originalRefetch); - }); - - it('should use warnDisabledRefetch when params is idle', () => { - const originalRefetch = jest.fn(); - mockUseInfiniteQuery.mockReturnValue(createMockInfiniteResult(originalRefetch) as any); - - const {result} = renderHook(() => useQueryData(infiniteDataSource, idle)); - - expect(result.current.refetch).toBe(mockWarnDisabledRefetch); - expect(result.current.refetch).not.toBe(originalRefetch); - }); - }); -}); diff --git a/src/react-query/impl/infinite/hooks.ts b/src/react-query/impl/infinite/hooks.ts index 36300c9..6f30a1b 100644 --- a/src/react-query/impl/infinite/hooks.ts +++ b/src/react-query/impl/infinite/hooks.ts @@ -1,6 +1,6 @@ import {useMemo} from 'react'; -import {skipToken, useInfiniteQuery} from '@tanstack/react-query'; +import {useInfiniteQuery} from '@tanstack/react-query'; import type {InfiniteData, InfiniteQueryObserverOptions} from '@tanstack/react-query'; import type { @@ -16,7 +16,6 @@ import type { } from '../../../core'; import {useRefetchInterval} from '../../hooks/useRefetchInterval'; import {normalizeStatus} from '../../utils/normalizeStatus'; -import {warnDisabledRefetch} from '../../utils/warnDisabledRefetch'; import type {AnyInfiniteQueryDataSource, InfiniteQueryObserverExtendedOptions} from './types'; import {composeOptions} from './utils'; @@ -64,14 +63,11 @@ export const useInfiniteQueryData = ; }; diff --git a/src/react-query/impl/plain/hooks.ts b/src/react-query/impl/plain/hooks.ts index 3346970..b6c4063 100644 --- a/src/react-query/impl/plain/hooks.ts +++ b/src/react-query/impl/plain/hooks.ts @@ -1,4 +1,4 @@ -import {type QueryObserverOptions, skipToken, useQuery} from '@tanstack/react-query'; +import {type QueryObserverOptions, useQuery} from '@tanstack/react-query'; import type { DataSourceContext, @@ -12,7 +12,6 @@ import type { } from '../../../core'; import {useRefetchInterval} from '../../hooks/useRefetchInterval'; import {normalizeStatus} from '../../utils/normalizeStatus'; -import {warnDisabledRefetch} from '../../utils/warnDisabledRefetch'; import type {AnyPlainQueryDataSource, QueryObserverExtendedOptions} from './types'; import {composeOptions} from './utils'; @@ -53,12 +52,9 @@ export const usePlainQueryData = ( const composedOptions = usePlainQueryDataOptions(extendedOptions); const state = useQuery(composedOptions); - const isDisabled = composedOptions.enabled === false || composedOptions.queryFn === skipToken; - return { ...state, status: normalizeStatus(state.status, state.fetchStatus), originalStatus: state.status, - refetch: isDisabled ? warnDisabledRefetch : state.refetch, } as DataSourceState; }; diff --git a/src/react-query/types/options.ts b/src/react-query/types/options.ts index f04eebe..27b6839 100644 --- a/src/react-query/types/options.ts +++ b/src/react-query/types/options.ts @@ -11,11 +11,6 @@ export interface QueryDataAdditionalOptions< TQueryKey extends QueryKey = QueryKey, > { refetchInterval?: RefetchInterval; - /** - * @deprecated The use of the enabled option is deprecated. - * It is recommended to use idle as query parameters to control query state. - */ - enabled?: boolean; /** Normalization configuration (enable/disable) */ normalize?: boolean; /** Optimistic data update configuration */ diff --git a/src/react-query/utils/warn.ts b/src/react-query/utils/warn.ts deleted file mode 100644 index 061762f..0000000 --- a/src/react-query/utils/warn.ts +++ /dev/null @@ -1,8 +0,0 @@ -export function warn(msg: string) { - if (!msg || process.env.NODE_ENV === 'production') { - return; - } - - // eslint-disable-next-line no-console - console.warn(msg); -} diff --git a/src/react-query/utils/warnDisabledRefetch.ts b/src/react-query/utils/warnDisabledRefetch.ts deleted file mode 100644 index 1eaceef..0000000 --- a/src/react-query/utils/warnDisabledRefetch.ts +++ /dev/null @@ -1,5 +0,0 @@ -import {warn} from './warn'; - -export const warnDisabledRefetch = () => { - warn('Disabled refetch is called'); -}; From aeac9320a9affd21dbe42be087b5aebc3ff35d3e Mon Sep 17 00:00:00 2001 From: NasgulNexus Date: Fri, 12 Dec 2025 12:32:48 +0100 Subject: [PATCH 2/3] Revert "Revert manual disabled (#43)" This reverts commit 254dafc9ec63a2f4da24493403f33e8369cfdb97. --- .../__tests__/useQueryData.refetch.test.ts | 180 ++++++++++++++++++ src/react-query/impl/infinite/hooks.ts | 6 +- src/react-query/impl/plain/hooks.ts | 6 +- src/react-query/types/options.ts | 5 + src/react-query/utils/warn.ts | 8 + src/react-query/utils/warnDisabledRefetch.ts | 5 + 6 files changed, 208 insertions(+), 2 deletions(-) create mode 100644 src/react-query/hooks/__tests__/useQueryData.refetch.test.ts create mode 100644 src/react-query/utils/warn.ts create mode 100644 src/react-query/utils/warnDisabledRefetch.ts diff --git a/src/react-query/hooks/__tests__/useQueryData.refetch.test.ts b/src/react-query/hooks/__tests__/useQueryData.refetch.test.ts new file mode 100644 index 0000000..2e9c9eb --- /dev/null +++ b/src/react-query/hooks/__tests__/useQueryData.refetch.test.ts @@ -0,0 +1,180 @@ +import {QueryClient, useInfiniteQuery, useQuery} from '@tanstack/react-query'; +import {renderHook} from '@testing-library/react'; + +import {idle} from '../../../core'; +import type {AnyInfiniteQueryDataSource} from '../../impl/infinite/types'; +import type {AnyPlainQueryDataSource} from '../../impl/plain/types'; +import {warnDisabledRefetch} from '../../utils/warnDisabledRefetch'; +import {useQueryContext} from '../useQueryContext'; +import {useQueryData} from '../useQueryData'; + +jest.mock('@tanstack/react-query', () => ({ + ...jest.requireActual('@tanstack/react-query'), + useQuery: jest.fn(), + useInfiniteQuery: jest.fn(), +})); + +jest.mock('../useQueryContext'); +jest.mock('../../utils/warnDisabledRefetch'); + +const mockUseQuery = useQuery as jest.MockedFunction; +const mockUseInfiniteQuery = useInfiniteQuery as jest.MockedFunction; +const mockWarnDisabledRefetch = warnDisabledRefetch as jest.MockedFunction< + typeof warnDisabledRefetch +>; + +describe('useQueryData refetch behavior', () => { + const mockQueryClient = new QueryClient(); + const mockContext = {queryClient: mockQueryClient}; + + beforeEach(() => { + jest.clearAllMocks(); + (useQueryContext as jest.Mock).mockReturnValue(mockContext); + }); + + const createMockQueryResult = (refetch = jest.fn()) => ({ + data: 'test-data', + error: null, + status: 'success' as const, + fetchStatus: 'idle' as const, + isLoading: false, + isError: false, + isSuccess: true, + isPending: false, + refetch, + dataUpdatedAt: Date.now(), + errorUpdatedAt: 0, + failureCount: 0, + failureReason: null, + isFetched: true, + isFetchedAfterMount: true, + isFetching: false, + isInitialLoading: false, + isLoadingError: false, + isPaused: false, + isPlaceholderData: false, + isPreviousData: false, + isRefetchError: false, + isRefetching: false, + isStale: false, + promise: Promise.resolve('test-data'), + }); + + const createMockInfiniteResult = (refetch = jest.fn()) => ({ + data: {pages: [['item1'], ['item2']], pageParams: [undefined, 'next-page']}, + error: null, + status: 'success' as const, + fetchStatus: 'idle' as const, + isLoading: false, + isError: false, + isSuccess: true, + isPending: false, + refetch, + hasNextPage: false, + hasPreviousPage: false, + fetchNextPage: jest.fn(), + fetchPreviousPage: jest.fn(), + isFetchingNextPage: false, + isFetchingPreviousPage: false, + dataUpdatedAt: Date.now(), + errorUpdatedAt: 0, + failureCount: 0, + failureReason: null, + isFetched: true, + isFetchedAfterMount: true, + isFetching: false, + isInitialLoading: false, + isLoadingError: false, + isPaused: false, + isPlaceholderData: false, + isPreviousData: false, + isRefetchError: false, + isRefetching: false, + isStale: false, + promise: Promise.resolve({ + pages: [['item1'], ['item2']], + pageParams: [undefined, 'next-page'], + }), + }); + + describe('plain data source', () => { + const plainDataSource: AnyPlainQueryDataSource = { + type: 'plain', + name: 'test-plain', + fetch: jest.fn().mockResolvedValue({data: 'test-data'}), + }; + + it('should use original refetch when no enabled option', () => { + const originalRefetch = jest.fn(); + mockUseQuery.mockReturnValue(createMockQueryResult(originalRefetch) as any); + + const {result} = renderHook(() => useQueryData(plainDataSource, {id: 1})); + + expect(result.current.refetch).toBe(originalRefetch); + expect(result.current.refetch).not.toBe(mockWarnDisabledRefetch); + }); + + it('should use warnDisabledRefetch when enabled: false', () => { + const originalRefetch = jest.fn(); + mockUseQuery.mockReturnValue(createMockQueryResult(originalRefetch) as any); + + const {result} = renderHook(() => + useQueryData(plainDataSource, {id: 1}, {enabled: false}), + ); + + expect(result.current.refetch).toBe(mockWarnDisabledRefetch); + expect(result.current.refetch).not.toBe(originalRefetch); + }); + + it('should use warnDisabledRefetch when params is idle', () => { + const originalRefetch = jest.fn(); + mockUseQuery.mockReturnValue(createMockQueryResult(originalRefetch) as any); + + const {result} = renderHook(() => useQueryData(plainDataSource, idle)); + + expect(result.current.refetch).toBe(mockWarnDisabledRefetch); + expect(result.current.refetch).not.toBe(originalRefetch); + }); + }); + + describe('infinite data source', () => { + const infiniteDataSource: AnyInfiniteQueryDataSource = { + type: 'infinite', + name: 'test-infinite', + fetch: jest.fn().mockResolvedValue({data: ['item1', 'item2']}), + next: jest.fn(), + }; + + it('should use original refetch when no enabled option', () => { + const originalRefetch = jest.fn(); + mockUseInfiniteQuery.mockReturnValue(createMockInfiniteResult(originalRefetch) as any); + + const {result} = renderHook(() => useQueryData(infiniteDataSource, {id: 1})); + + expect(result.current.refetch).toBe(originalRefetch); + expect(result.current.refetch).not.toBe(mockWarnDisabledRefetch); + }); + + it('should use warnDisabledRefetch when enabled: false', () => { + const originalRefetch = jest.fn(); + mockUseInfiniteQuery.mockReturnValue(createMockInfiniteResult(originalRefetch) as any); + + const {result} = renderHook(() => + useQueryData(infiniteDataSource, {id: 1}, {enabled: false}), + ); + + expect(result.current.refetch).toBe(mockWarnDisabledRefetch); + expect(result.current.refetch).not.toBe(originalRefetch); + }); + + it('should use warnDisabledRefetch when params is idle', () => { + const originalRefetch = jest.fn(); + mockUseInfiniteQuery.mockReturnValue(createMockInfiniteResult(originalRefetch) as any); + + const {result} = renderHook(() => useQueryData(infiniteDataSource, idle)); + + expect(result.current.refetch).toBe(mockWarnDisabledRefetch); + expect(result.current.refetch).not.toBe(originalRefetch); + }); + }); +}); diff --git a/src/react-query/impl/infinite/hooks.ts b/src/react-query/impl/infinite/hooks.ts index 6f30a1b..36300c9 100644 --- a/src/react-query/impl/infinite/hooks.ts +++ b/src/react-query/impl/infinite/hooks.ts @@ -1,6 +1,6 @@ import {useMemo} from 'react'; -import {useInfiniteQuery} from '@tanstack/react-query'; +import {skipToken, useInfiniteQuery} from '@tanstack/react-query'; import type {InfiniteData, InfiniteQueryObserverOptions} from '@tanstack/react-query'; import type { @@ -16,6 +16,7 @@ import type { } from '../../../core'; import {useRefetchInterval} from '../../hooks/useRefetchInterval'; import {normalizeStatus} from '../../utils/normalizeStatus'; +import {warnDisabledRefetch} from '../../utils/warnDisabledRefetch'; import type {AnyInfiniteQueryDataSource, InfiniteQueryObserverExtendedOptions} from './types'; import {composeOptions} from './utils'; @@ -63,11 +64,14 @@ export const useInfiniteQueryData = ; }; diff --git a/src/react-query/impl/plain/hooks.ts b/src/react-query/impl/plain/hooks.ts index b6c4063..3346970 100644 --- a/src/react-query/impl/plain/hooks.ts +++ b/src/react-query/impl/plain/hooks.ts @@ -1,4 +1,4 @@ -import {type QueryObserverOptions, useQuery} from '@tanstack/react-query'; +import {type QueryObserverOptions, skipToken, useQuery} from '@tanstack/react-query'; import type { DataSourceContext, @@ -12,6 +12,7 @@ import type { } from '../../../core'; import {useRefetchInterval} from '../../hooks/useRefetchInterval'; import {normalizeStatus} from '../../utils/normalizeStatus'; +import {warnDisabledRefetch} from '../../utils/warnDisabledRefetch'; import type {AnyPlainQueryDataSource, QueryObserverExtendedOptions} from './types'; import {composeOptions} from './utils'; @@ -52,9 +53,12 @@ export const usePlainQueryData = ( const composedOptions = usePlainQueryDataOptions(extendedOptions); const state = useQuery(composedOptions); + const isDisabled = composedOptions.enabled === false || composedOptions.queryFn === skipToken; + return { ...state, status: normalizeStatus(state.status, state.fetchStatus), originalStatus: state.status, + refetch: isDisabled ? warnDisabledRefetch : state.refetch, } as DataSourceState; }; diff --git a/src/react-query/types/options.ts b/src/react-query/types/options.ts index 27b6839..f04eebe 100644 --- a/src/react-query/types/options.ts +++ b/src/react-query/types/options.ts @@ -11,6 +11,11 @@ export interface QueryDataAdditionalOptions< TQueryKey extends QueryKey = QueryKey, > { refetchInterval?: RefetchInterval; + /** + * @deprecated The use of the enabled option is deprecated. + * It is recommended to use idle as query parameters to control query state. + */ + enabled?: boolean; /** Normalization configuration (enable/disable) */ normalize?: boolean; /** Optimistic data update configuration */ diff --git a/src/react-query/utils/warn.ts b/src/react-query/utils/warn.ts new file mode 100644 index 0000000..061762f --- /dev/null +++ b/src/react-query/utils/warn.ts @@ -0,0 +1,8 @@ +export function warn(msg: string) { + if (!msg || process.env.NODE_ENV === 'production') { + return; + } + + // eslint-disable-next-line no-console + console.warn(msg); +} diff --git a/src/react-query/utils/warnDisabledRefetch.ts b/src/react-query/utils/warnDisabledRefetch.ts new file mode 100644 index 0000000..1eaceef --- /dev/null +++ b/src/react-query/utils/warnDisabledRefetch.ts @@ -0,0 +1,5 @@ +import {warn} from './warn'; + +export const warnDisabledRefetch = () => { + warn('Disabled refetch is called'); +}; From fb8c0b758c87ef14302c871d1d28a264335a6cf1 Mon Sep 17 00:00:00 2001 From: NasgulNexus Date: Fri, 12 Dec 2025 12:43:57 +0100 Subject: [PATCH 3/3] feat: disabled refetch return data --- .../__tests__/useQueryData.refetch.test.ts | 21 +++++++++++++------ src/react-query/impl/infinite/hooks.ts | 3 ++- src/react-query/impl/infinite/types.ts | 1 + src/react-query/impl/plain/hooks.ts | 3 ++- src/react-query/impl/plain/types.ts | 8 ++++++- src/react-query/utils/warnDisabledRefetch.ts | 2 +- src/react-query/utils/wrapRefetch.ts | 9 ++++++++ 7 files changed, 37 insertions(+), 10 deletions(-) create mode 100644 src/react-query/utils/wrapRefetch.ts diff --git a/src/react-query/hooks/__tests__/useQueryData.refetch.test.ts b/src/react-query/hooks/__tests__/useQueryData.refetch.test.ts index 2e9c9eb..cde00b3 100644 --- a/src/react-query/hooks/__tests__/useQueryData.refetch.test.ts +++ b/src/react-query/hooks/__tests__/useQueryData.refetch.test.ts @@ -104,14 +104,17 @@ describe('useQueryData refetch behavior', () => { fetch: jest.fn().mockResolvedValue({data: 'test-data'}), }; - it('should use original refetch when no enabled option', () => { - const originalRefetch = jest.fn(); + it('should wrap refetch when no enabled option', async () => { + const originalRefetch = jest.fn().mockResolvedValue({data: 'test', status: 'success'}); mockUseQuery.mockReturnValue(createMockQueryResult(originalRefetch) as any); const {result} = renderHook(() => useQueryData(plainDataSource, {id: 1})); - expect(result.current.refetch).toBe(originalRefetch); + expect(result.current.refetch).not.toBe(originalRefetch); expect(result.current.refetch).not.toBe(mockWarnDisabledRefetch); + + await result.current.refetch(); + expect(originalRefetch).toHaveBeenCalledTimes(1); }); it('should use warnDisabledRefetch when enabled: false', () => { @@ -145,14 +148,20 @@ describe('useQueryData refetch behavior', () => { next: jest.fn(), }; - it('should use original refetch when no enabled option', () => { - const originalRefetch = jest.fn(); + it('should wrap refetch when no enabled option', async () => { + const originalRefetch = jest.fn().mockResolvedValue({ + data: {pages: [], pageParams: []}, + status: 'success', + }); mockUseInfiniteQuery.mockReturnValue(createMockInfiniteResult(originalRefetch) as any); const {result} = renderHook(() => useQueryData(infiniteDataSource, {id: 1})); - expect(result.current.refetch).toBe(originalRefetch); + expect(result.current.refetch).not.toBe(originalRefetch); expect(result.current.refetch).not.toBe(mockWarnDisabledRefetch); + + await result.current.refetch(); + expect(originalRefetch).toHaveBeenCalledTimes(1); }); it('should use warnDisabledRefetch when enabled: false', () => { diff --git a/src/react-query/impl/infinite/hooks.ts b/src/react-query/impl/infinite/hooks.ts index 36300c9..2a0e8c1 100644 --- a/src/react-query/impl/infinite/hooks.ts +++ b/src/react-query/impl/infinite/hooks.ts @@ -17,6 +17,7 @@ import type { import {useRefetchInterval} from '../../hooks/useRefetchInterval'; import {normalizeStatus} from '../../utils/normalizeStatus'; import {warnDisabledRefetch} from '../../utils/warnDisabledRefetch'; +import {wrapRefetch} from '../../utils/wrapRefetch'; import type {AnyInfiniteQueryDataSource, InfiniteQueryObserverExtendedOptions} from './types'; import {composeOptions} from './utils'; @@ -72,6 +73,6 @@ export const useInfiniteQueryData = ; }; diff --git a/src/react-query/impl/infinite/types.ts b/src/react-query/impl/infinite/types.ts index 042f302..a9ead6d 100644 --- a/src/react-query/impl/infinite/types.ts +++ b/src/react-query/impl/infinite/types.ts @@ -84,6 +84,7 @@ type ResultWrapper = { status: DataLoaderStatus; data: Array>, 1>>; + refetch: () => Promise; } > & { originalStatus: TResult['status']; diff --git a/src/react-query/impl/plain/hooks.ts b/src/react-query/impl/plain/hooks.ts index 3346970..ba4de78 100644 --- a/src/react-query/impl/plain/hooks.ts +++ b/src/react-query/impl/plain/hooks.ts @@ -13,6 +13,7 @@ import type { import {useRefetchInterval} from '../../hooks/useRefetchInterval'; import {normalizeStatus} from '../../utils/normalizeStatus'; import {warnDisabledRefetch} from '../../utils/warnDisabledRefetch'; +import {wrapRefetch} from '../../utils/wrapRefetch'; import type {AnyPlainQueryDataSource, QueryObserverExtendedOptions} from './types'; import {composeOptions} from './utils'; @@ -59,6 +60,6 @@ export const usePlainQueryData = ( ...state, status: normalizeStatus(state.status, state.fetchStatus), originalStatus: state.status, - refetch: isDisabled ? warnDisabledRefetch : state.refetch, + refetch: isDisabled ? warnDisabledRefetch : wrapRefetch(state.refetch), } as DataSourceState; }; diff --git a/src/react-query/impl/plain/types.ts b/src/react-query/impl/plain/types.ts index 381898e..0b34d4d 100644 --- a/src/react-query/impl/plain/types.ts +++ b/src/react-query/impl/plain/types.ts @@ -53,5 +53,11 @@ export type AnyPlainQueryDataSource = PlainQueryDataSource = TResult extends QueryObserverResult, TError> - ? Overwrite & {originalStatus: TResult['status']} + ? Overwrite< + TResult, + { + status: DataLoaderStatus; + refetch: () => Promise; + } + > & {originalStatus: TResult['status']} : never; diff --git a/src/react-query/utils/warnDisabledRefetch.ts b/src/react-query/utils/warnDisabledRefetch.ts index 1eaceef..b3dfd79 100644 --- a/src/react-query/utils/warnDisabledRefetch.ts +++ b/src/react-query/utils/warnDisabledRefetch.ts @@ -1,5 +1,5 @@ import {warn} from './warn'; -export const warnDisabledRefetch = () => { +export const warnDisabledRefetch = async (): Promise => { warn('Disabled refetch is called'); }; diff --git a/src/react-query/utils/wrapRefetch.ts b/src/react-query/utils/wrapRefetch.ts new file mode 100644 index 0000000..d7b0026 --- /dev/null +++ b/src/react-query/utils/wrapRefetch.ts @@ -0,0 +1,9 @@ +import type {QueryObserverResult, RefetchOptions} from '@tanstack/react-query'; + +export function wrapRefetch( + refetch: (options?: RefetchOptions) => Promise>, +): (options?: RefetchOptions) => Promise { + return async (options?: RefetchOptions) => { + await refetch(options); + }; +}