diff --git a/.changeset/tidy-streams-stop.md b/.changeset/tidy-streams-stop.md new file mode 100644 index 0000000000..58b1f7e648 --- /dev/null +++ b/.changeset/tidy-streams-stop.md @@ -0,0 +1,5 @@ +--- +'@tanstack/query-core': patch +--- + +Prevent cancelled streamed queries from writing to the cache or starting a delayed stream, even when the stream does not consume the abort signal. diff --git a/packages/angular-query-experimental/src/__tests__/inject-query.test.ts b/packages/angular-query-experimental/src/__tests__/inject-query.test.ts index 9393c42b47..7a258334d8 100644 --- a/packages/angular-query-experimental/src/__tests__/inject-query.test.ts +++ b/packages/angular-query-experimental/src/__tests__/inject-query.test.ts @@ -209,12 +209,15 @@ describe('injectQuery', () => { TestBed.tick() expect(queryFn).toHaveBeenCalledTimes(2) // should call queryFn with context containing the new queryKey - expect(queryFn).toHaveBeenNthCalledWith(2, { - client: queryClient, - meta: undefined, - queryKey: key2, - signal: expect.anything(), - }) + expect(queryFn).toHaveBeenNthCalledWith( + 2, + expect.objectContaining({ + client: queryClient, + meta: undefined, + queryKey: key2, + signal: expect.anything(), + }), + ) }) it('should only run query once enabled signal is set to true', async () => { diff --git a/packages/query-core/src/__tests__/infiniteQueryBehavior.test.tsx b/packages/query-core/src/__tests__/infiniteQueryBehavior.test.tsx index 1134771f14..cbd88732c3 100644 --- a/packages/query-core/src/__tests__/infiniteQueryBehavior.test.tsx +++ b/packages/query-core/src/__tests__/infiniteQueryBehavior.test.tsx @@ -88,7 +88,7 @@ describe('InfiniteQueryBehavior', () => { data: { pages: [1], pageParams: [1] }, }) - expect(queryFnSpy).toHaveBeenNthCalledWith(1, { + expect(queryFnSpy.mock.calls[0]?.[0]).toMatchObject({ queryKey: key, client: queryClient, pageParam: 1, @@ -101,7 +101,7 @@ describe('InfiniteQueryBehavior', () => { // Fetch the second page await observer.fetchNextPage() - expect(queryFnSpy).toHaveBeenNthCalledWith(1, { + expect(queryFnSpy.mock.calls[0]?.[0]).toMatchObject({ queryKey: key, client: queryClient, pageParam: 2, @@ -119,7 +119,7 @@ describe('InfiniteQueryBehavior', () => { // Fetch the page before the first page await observer.fetchPreviousPage() - expect(queryFnSpy).toHaveBeenNthCalledWith(1, { + expect(queryFnSpy.mock.calls[0]?.[0]).toMatchObject({ queryKey: key, client: queryClient, pageParam: 0, @@ -138,7 +138,7 @@ describe('InfiniteQueryBehavior', () => { // Fetch the page before await observer.fetchPreviousPage() - expect(queryFnSpy).toHaveBeenNthCalledWith(1, { + expect(queryFnSpy.mock.calls[0]?.[0]).toMatchObject({ queryKey: key, client: queryClient, pageParam: -1, @@ -156,7 +156,7 @@ describe('InfiniteQueryBehavior', () => { // Fetch the page after await observer.fetchNextPage() - expect(queryFnSpy).toHaveBeenNthCalledWith(1, { + expect(queryFnSpy.mock.calls[0]?.[0]).toMatchObject({ queryKey: key, client: queryClient, pageParam: 1, @@ -178,7 +178,7 @@ describe('InfiniteQueryBehavior', () => { // Only 2 pages should refetch expect(queryFnSpy).toHaveBeenCalledTimes(2) - expect(queryFnSpy).toHaveBeenNthCalledWith(1, { + expect(queryFnSpy.mock.calls[0]?.[0]).toMatchObject({ queryKey: key, client: queryClient, pageParam: 0, @@ -187,7 +187,7 @@ describe('InfiniteQueryBehavior', () => { signal: abortSignal, }) - expect(queryFnSpy).toHaveBeenNthCalledWith(2, { + expect(queryFnSpy.mock.calls[1]?.[0]).toMatchObject({ queryKey: key, client: queryClient, pageParam: 1, @@ -241,7 +241,7 @@ describe('InfiniteQueryBehavior', () => { expect(queryFnSpy).toHaveBeenCalledTimes(1) - expect(queryFnSpy).toHaveBeenNthCalledWith(1, { + expect(queryFnSpy.mock.calls[0]?.[0]).toMatchObject({ queryKey: key, client: queryClient, pageParam: 1, @@ -298,7 +298,7 @@ describe('InfiniteQueryBehavior', () => { expect(queryFnSpy).toHaveBeenCalledTimes(1) - expect(queryFnSpy).toHaveBeenNthCalledWith(1, { + expect(queryFnSpy.mock.calls[0]?.[0]).toMatchObject({ queryKey: key, client: queryClient, pageParam: 2, diff --git a/packages/query-core/src/__tests__/streamedQuery.test.tsx b/packages/query-core/src/__tests__/streamedQuery.test.tsx index 2905ac3229..545419ba5f 100644 --- a/packages/query-core/src/__tests__/streamedQuery.test.tsx +++ b/packages/query-core/src/__tests__/streamedQuery.test.tsx @@ -396,6 +396,170 @@ describe('streamedQuery', () => { }) }) + it.each(['append', 'replace'] as const)( + 'should stop %s writes after explicit cancellation when the stream ignores the signal', + async (refetchMode) => { + const key = createKey() + queryClient.setQueryData(key, [99]) + const observer = new QueryObserver(queryClient, { + queryKey: key, + queryFn: streamedQuery({ + streamFn: () => createAsyncNumberGenerator(3), + refetchMode, + }), + persister: (queryFn, context) => queryFn({ ...context }), + }) + + const unsubscribe = observer.subscribe(vi.fn()) + await vi.advanceTimersByTimeAsync(50) + await queryClient.cancelQueries({ queryKey: key }) + const cancelledData = queryClient.getQueryData(key) + expect(cancelledData).toStrictEqual( + refetchMode === 'append' ? [99, 0] : [99], + ) + + await vi.advanceTimersByTimeAsync(150) + expect(queryClient.getQueryData(key)).toStrictEqual(cancelledData) + unsubscribe() + }, + ) + + it('should preserve a non-streamed replacement when the old stream ignores the signal', async () => { + const key = createKey() + const queryFn = streamedQuery({ + streamFn: () => createAsyncNumberGenerator(3), + }) + const observer = new QueryObserver(queryClient, { + queryKey: key, + queryFn: (context) => queryFn(context), + }) + + const unsubscribe = observer.subscribe(vi.fn()) + await vi.advanceTimersByTimeAsync(50) + observer.setOptions({ queryKey: key, queryFn: () => [100] }) + await observer.refetch() + await vi.advanceTimersByTimeAsync(150) + + expect(queryClient.getQueryData(key)).toStrictEqual([100]) + unsubscribe() + }) + + it('should preserve the new stream when the old stream ignores the signal', async () => { + const key = createKey() + let offset = 0 + const observer = new QueryObserver(queryClient, { + queryKey: key, + queryFn: streamedQuery({ + streamFn: () => { + const stream = createAsyncNumberGenerator(3, offset) + offset += 100 + return stream + }, + }), + }) + + const unsubscribe = observer.subscribe(vi.fn()) + await vi.advanceTimersByTimeAsync(50) + void observer.refetch() + await vi.advanceTimersByTimeAsync(150) + + expect(queryClient.getQueryData(key)).toStrictEqual([100, 101, 102]) + unsubscribe() + }) + + it('should ignore a chunk queued just before cancellation', async () => { + const key = createKey() + queryClient.setQueryData(key, [99]) + let resolveChunk: (chunk: IteratorResult) => void = () => { + throw new Error('The iterator has not started') + } + const next = vi.fn<() => Promise>>( + () => + new Promise>((resolve) => { + resolveChunk = resolve + }), + ) + const observer = new QueryObserver(queryClient, { + queryKey: key, + queryFn: streamedQuery({ + refetchMode: 'append', + streamFn: () => ({ + [Symbol.asyncIterator]: () => ({ next }), + }), + }), + }) + + const unsubscribe = observer.subscribe(vi.fn()) + await vi.advanceTimersByTimeAsync(0) + resolveChunk({ done: false, value: 1 }) + void queryClient.cancelQueries({ queryKey: key }) + await vi.advanceTimersByTimeAsync(0) + + expect(queryClient.getQueryData(key)).toStrictEqual([99]) + expect(next).toHaveBeenCalledTimes(1) + unsubscribe() + }) + + it.each(['queryFn', 'persister'] as const)( + 'should not start a stream after cancellation during a delayed %s', + async (delayIn) => { + const key = createKey() + queryClient.setQueryData(key, [99]) + const streamFn = vi.fn<() => AsyncIterable>(() => + createAsyncNumberGenerator(1), + ) + const queryFn = streamedQuery({ streamFn }) + const observer = new QueryObserver(queryClient, { + queryKey: key, + queryFn: + delayIn === 'queryFn' + ? async (context) => { + await sleep(50) + return queryFn(context) + } + : queryFn, + persister: + delayIn === 'persister' + ? async (fn, context) => { + await sleep(50) + return fn({ ...context }) + } + : undefined, + }) + + const unsubscribe = observer.subscribe(vi.fn()) + await queryClient.cancelQueries({ queryKey: key }) + queryClient.setQueryData(key, [100]) + await vi.advanceTimersByTimeAsync(100) + + expect(streamFn).not.toHaveBeenCalled() + expect(queryClient.getQueryData(key)).toStrictEqual([100]) + unsubscribe() + }, + ) + + it('should keep a custom signal getter lazy', async () => { + const key = createKey() + const controller = new AbortController() + const getSignal = vi.fn<() => AbortSignal>(() => controller.signal) + const queryFn = streamedQuery({ + streamFn: () => createAsyncNumberGenerator(1), + }) + + const result = queryFn({ + client: queryClient, + queryKey: key, + meta: undefined, + get signal() { + return getSignal() + }, + }) + await vi.advanceTimersByTimeAsync(50) + + await expect(result).resolves.toStrictEqual([0]) + expect(getSignal).not.toHaveBeenCalled() + }) + it('should support custom reducer', async () => { const key = createKey() diff --git a/packages/query-core/src/__tests__/utils.test.tsx b/packages/query-core/src/__tests__/utils.test.tsx index 3269e47239..ec3680791f 100644 --- a/packages/query-core/src/__tests__/utils.test.tsx +++ b/packages/query-core/src/__tests__/utils.test.tsx @@ -728,6 +728,20 @@ describe('core/utils', () => { }) describe('addConsumeAwareSignal', () => { + it('should allow page parameters to be passed to URLSearchParams', () => { + const controller = new AbortController() + const context = addConsumeAwareSignal( + { pageParam: 'cursor' }, + () => controller.signal, + vi.fn(), + controller.signal, + ) + const { signal, ...params } = context + + expect(signal).toBe(controller.signal) + expect(new URLSearchParams(params).toString()).toBe('pageParam=cursor') + }) + it('should expose the signal on the query context while preserving its properties', () => { const controller = new AbortController() const key = createKey() diff --git a/packages/query-core/src/infiniteQueryBehavior.ts b/packages/query-core/src/infiniteQueryBehavior.ts index 38422a3380..20bc95ff22 100644 --- a/packages/query-core/src/infiniteQueryBehavior.ts +++ b/packages/query-core/src/infiniteQueryBehavior.ts @@ -3,7 +3,9 @@ import { addToEnd, addToStart, ensureQueryFn, + fetchSignal, } from './utils' +import type { FetchSignalContext } from './utils' import type { QueryBehavior } from './query' import type { InfiniteData, @@ -35,11 +37,13 @@ export function infiniteQueryBehavior( const fetchFn = async () => { let cancelled = false - const addSignalProperty = (object: unknown) => { + const signalContext: FetchSignalContext = context + const addSignalProperty = (object: object) => { addConsumeAwareSignal( object, () => context.signal, () => (cancelled = true), + signalContext[fetchSignal], ) } diff --git a/packages/query-core/src/query.ts b/packages/query-core/src/query.ts index 07cd791ccf..44d84aad5f 100644 --- a/packages/query-core/src/query.ts +++ b/packages/query-core/src/query.ts @@ -1,5 +1,6 @@ import { ensureQueryFn, + fetchSignal, noop, replaceData, resolveQueryValue, @@ -749,12 +750,15 @@ export class Query< // Adds an enumerable signal property to the object that // which sets abortSignalConsumed to true when the signal // is read. - const addSignalProperty = (object: unknown) => { - Object.defineProperty(object, 'signal', { - enumerable: true, - get: () => { - this.#abortSignalConsumed = true - return abortController.signal + const addSignalProperty = (object: object) => { + Object.defineProperties(object, { + [fetchSignal]: { value: abortController.signal, enumerable: true }, + signal: { + enumerable: true, + get: () => { + this.#abortSignalConsumed = true + return abortController.signal + }, }, }) } diff --git a/packages/query-core/src/streamedQuery.ts b/packages/query-core/src/streamedQuery.ts index 4a2c59b948..c7b9e759de 100644 --- a/packages/query-core/src/streamedQuery.ts +++ b/packages/query-core/src/streamedQuery.ts @@ -1,4 +1,5 @@ -import { addConsumeAwareSignal, addToEnd } from './utils' +import { addConsumeAwareSignal, addToEnd, fetchSignal } from './utils' +import type { FetchSignalContext } from './utils' import type { OmitKeyof, QueryFunction, @@ -54,6 +55,8 @@ type StreamedQueryParams = * Data will be an Array of all the chunks received. * The query will be in a 'pending' state until the first chunk of data is received, but will go to 'success' after that. * The query will stay in fetchStatus 'fetching' until the stream ends. + * Explicit cancellation stops further cache updates, even if `streamFn` does not read `signal`. + * If `streamFn` does not read `signal`, the stream continues after the last observer unsubscribes. * @param options - The `streamFn` that returns an AsyncIterable to stream data from, and the optional * `refetchMode`, `reducer`, and `initialValue` options. * @returns A query function to pass as `queryFn`. @@ -82,6 +85,12 @@ export function streamedQuery< TQueryKey > { return async (context) => { + const signalContext: FetchSignalContext = context + const signal = signalContext[fetchSignal] + if (signal?.aborted) { + return initialValue + } + const query = context.client .getQueryCache() .find({ queryKey: context.queryKey, exact: true }) @@ -108,14 +117,16 @@ export function streamedQuery< }, () => context.signal, () => (cancelled = true), + signal, ) + const isStreamInactive = () => cancelled || signal?.aborted === true const stream = await streamFn(streamFnContext) const isReplaceRefetch = isRefetch && refetchMode === 'replace' for await (const chunk of stream) { - if (cancelled) { + if (isStreamInactive()) { break } @@ -130,7 +141,7 @@ export function streamedQuery< } // finalize result: replace-refetching needs to write to the cache - if (isReplaceRefetch && !cancelled) { + if (isReplaceRefetch && !isStreamInactive()) { context.client.setQueryData(context.queryKey, result) } diff --git a/packages/query-core/src/utils.ts b/packages/query-core/src/utils.ts index a12f589c72..64e6a664ab 100644 --- a/packages/query-core/src/utils.ts +++ b/packages/query-core/src/utils.ts @@ -700,6 +700,16 @@ export function shouldThrowError) => boolean>( return !!throwOnError } +export const fetchSignal = Symbol() + +/** Internal view of a context that can expose its signal without consuming it. */ +export type FetchSignalContext = { + /** The public signal, whose getter can mark it consumed. */ + readonly signal: AbortSignal + /** The original fetch signal, absent on application-created contexts. */ + readonly [fetchSignal]?: AbortSignal +} + /** * Adds a lazy `signal` getter to an object, such as a query function context. The first time * `signal` is read, `onCancelled` is registered for the signal's `abort` event (or called right @@ -707,32 +717,37 @@ export function shouldThrowError) => boolean>( * @param object - The object to add the `signal` property to. * @param getSignal - Returns the `AbortSignal`. Called once, when `signal` is first read. * @param onCancelled - Called when the signal is aborted, if `signal` was read. + * @param internalSignal - The fetch signal to forward without consuming the getter. * @returns The same object, with the `signal` property added. */ -export function addConsumeAwareSignal( +export function addConsumeAwareSignal( object: T, getSignal: () => AbortSignal, onCancelled: () => void, + internalSignal?: AbortSignal, ): T & { signal: AbortSignal } { let consumed = false let signal: AbortSignal | undefined - Object.defineProperty(object, 'signal', { - enumerable: true, - get: () => { - signal ??= getSignal() - if (consumed) { + Object.defineProperties(object, { + [fetchSignal]: { value: internalSignal }, + signal: { + enumerable: true, + get: () => { + signal ??= getSignal() + if (consumed) { + return signal + } + + consumed = true + if (signal.aborted) { + onCancelled() + } else { + signal.addEventListener('abort', onCancelled, { once: true }) + } + return signal - } - - consumed = true - if (signal.aborted) { - onCancelled() - } else { - signal.addEventListener('abort', onCancelled, { once: true }) - } - - return signal + }, }, })