@tanstack/query-core 5.59.16 → 5.59.20

package/src/__tests__/infiniteQueryBehavior.test.tsx

@@ -1,427 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
-import { waitFor } from '@testing-library/react'
-import { CancelledError, InfiniteQueryObserver } from '..'
-import { createQueryClient, queryKey, sleep } from './utils'
-import type {
-  InfiniteData,
-  InfiniteQueryObserverResult,
-  QueryCache,
-  QueryClient,
-} from '..'
-
-describe('InfiniteQueryBehavior', () => {
-  let queryClient: QueryClient
-  let queryCache: QueryCache
-
-  beforeEach(() => {
-    queryClient = createQueryClient()
-    queryCache = queryClient.getQueryCache()
-    queryClient.mount()
-  })
-
-  afterEach(() => {
-    queryClient.clear()
-  })
-
-  test('InfiniteQueryBehavior should throw an error if the queryFn is not defined', async () => {
-    const key = queryKey()
-
-    const observer = new InfiniteQueryObserver(queryClient, {
-      queryKey: key,
-      retry: false,
-      initialPageParam: 1,
-      getNextPageParam: () => 2,
-    })
-
-    let observerResult:
-      | InfiniteQueryObserverResult<unknown, unknown>
-      | undefined
-
-    const unsubscribe = observer.subscribe((result) => {
-      observerResult = result
-    })
-
-    await waitFor(() => {
-      const query = queryCache.find({ queryKey: key })!
-      return expect(observerResult).toMatchObject({
-        isError: true,
-        error: new Error(`Missing queryFn: '${query.queryHash}'`),
-      })
-    })
-
-    unsubscribe()
-  })
-
-  test('InfiniteQueryBehavior should apply the maxPages option to limit the number of pages', async () => {
-    const key = queryKey()
-    let abortSignal: AbortSignal | null = null
-
-    const queryFnSpy = vi.fn().mockImplementation(({ pageParam, signal }) => {
-      abortSignal = signal
-      return pageParam
-    })
-
-    const observer = new InfiniteQueryObserver<number>(queryClient, {
-      queryKey: key,
-      queryFn: queryFnSpy,
-      getNextPageParam: (lastPage) => lastPage + 1,
-      getPreviousPageParam: (firstPage) => firstPage - 1,
-      maxPages: 2,
-      initialPageParam: 1,
-    })
-
-    let observerResult:
-      | InfiniteQueryObserverResult<unknown, unknown>
-      | undefined
-
-    const unsubscribe = observer.subscribe((result) => {
-      observerResult = result
-    })
-
-    // Wait for the first page to be fetched
-    await waitFor(() =>
-      expect(observerResult).toMatchObject({
-        isFetching: false,
-        data: { pages: [1], pageParams: [1] },
-      }),
-    )
-
-    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
-      queryKey: key,
-      pageParam: 1,
-      meta: undefined,
-      direction: 'forward',
-      signal: abortSignal,
-    })
-
-    queryFnSpy.mockClear()
-
-    // Fetch the second page
-    await observer.fetchNextPage()
-
-    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
-      queryKey: key,
-      pageParam: 2,
-      direction: 'forward',
-      meta: undefined,
-      signal: abortSignal,
-    })
-
-    expect(observerResult).toMatchObject({
-      isFetching: false,
-      data: { pages: [1, 2], pageParams: [1, 2] },
-    })
-
-    queryFnSpy.mockClear()
-
-    // Fetch the page before the first page
-    await observer.fetchPreviousPage()
-
-    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
-      queryKey: key,
-      pageParam: 0,
-      direction: 'backward',
-      meta: undefined,
-      signal: abortSignal,
-    })
-
-    // Only first two pages should be in the data
-    expect(observerResult).toMatchObject({
-      isFetching: false,
-      data: { pages: [0, 1], pageParams: [0, 1] },
-    })
-
-    queryFnSpy.mockClear()
-
-    // Fetch the page before
-    await observer.fetchPreviousPage()
-
-    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
-      queryKey: key,
-      pageParam: -1,
-      meta: undefined,
-      direction: 'backward',
-      signal: abortSignal,
-    })
-
-    expect(observerResult).toMatchObject({
-      isFetching: false,
-      data: { pages: [-1, 0], pageParams: [-1, 0] },
-    })
-
-    queryFnSpy.mockClear()
-
-    // Fetch the page after
-    await observer.fetchNextPage()
-
-    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
-      queryKey: key,
-      pageParam: 1,
-      meta: undefined,
-      direction: 'forward',
-      signal: abortSignal,
-    })
-
-    expect(observerResult).toMatchObject({
-      isFetching: false,
-      data: { pages: [0, 1] },
-    })
-
-    queryFnSpy.mockClear()
-
-    // Refetch the infinite query
-    await observer.refetch()
-
-    // Only 2 pages should refetch
-    expect(queryFnSpy).toHaveBeenCalledTimes(2)
-
-    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
-      queryKey: key,
-      pageParam: 0,
-      meta: undefined,
-      direction: 'forward',
-      signal: abortSignal,
-    })
-
-    expect(queryFnSpy).toHaveBeenNthCalledWith(2, {
-      queryKey: key,
-      pageParam: 1,
-      meta: undefined,
-      direction: 'forward',
-      signal: abortSignal,
-    })
-
-    unsubscribe()
-  })
-
-  test('InfiniteQueryBehavior should support query cancellation', async () => {
-    const key = queryKey()
-    let abortSignal: AbortSignal | null = null
-
-    const queryFnSpy = vi.fn().mockImplementation(({ pageParam, signal }) => {
-      abortSignal = signal
-      sleep(10)
-      return pageParam
-    })
-
-    const observer = new InfiniteQueryObserver<number>(queryClient, {
-      queryKey: key,
-      queryFn: queryFnSpy,
-      getNextPageParam: (lastPage) => lastPage + 1,
-      getPreviousPageParam: (firstPage) => firstPage - 1,
-      initialPageParam: 1,
-    })
-
-    let observerResult:
-      | InfiniteQueryObserverResult<unknown, unknown>
-      | undefined
-
-    const unsubscribe = observer.subscribe((result) => {
-      observerResult = result
-    })
-
-    const query = observer.getCurrentQuery()
-    query.cancel()
-
-    // Wait for the first page to be cancelled
-    await waitFor(() =>
-      expect(observerResult).toMatchObject({
-        isFetching: false,
-        isError: true,
-        error: new CancelledError(),
-        data: undefined,
-      }),
-    )
-
-    expect(queryFnSpy).toHaveBeenCalledTimes(1)
-
-    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
-      queryKey: key,
-      pageParam: 1,
-      meta: undefined,
-      direction: 'forward',
-      signal: abortSignal,
-    })
-
-    unsubscribe()
-  })
-
-  test('InfiniteQueryBehavior should not refetch pages if the query is cancelled', async () => {
-    const key = queryKey()
-    let abortSignal: AbortSignal | null = null
-
-    let queryFnSpy = vi.fn().mockImplementation(({ pageParam, signal }) => {
-      abortSignal = signal
-      return pageParam
-    })
-
-    const observer = new InfiniteQueryObserver<number>(queryClient, {
-      queryKey: key,
-      queryFn: queryFnSpy,
-      getNextPageParam: (lastPage) => lastPage + 1,
-      getPreviousPageParam: (firstPage) => firstPage - 1,
-      initialPageParam: 1,
-    })
-
-    let observerResult:
-      | InfiniteQueryObserverResult<unknown, unknown>
-      | undefined
-
-    const unsubscribe = observer.subscribe((result) => {
-      observerResult = result
-    })
-
-    // Wait for the first page to be fetched
-    await waitFor(() =>
-      expect(observerResult).toMatchObject({
-        isFetching: false,
-        data: { pages: [1], pageParams: [1] },
-      }),
-    )
-
-    queryFnSpy.mockClear()
-
-    // Fetch the second page
-    await observer.fetchNextPage()
-
-    expect(observerResult).toMatchObject({
-      isFetching: false,
-      data: { pages: [1, 2], pageParams: [1, 2] },
-    })
-
-    expect(queryFnSpy).toHaveBeenCalledTimes(1)
-
-    expect(queryFnSpy).toHaveBeenNthCalledWith(1, {
-      queryKey: key,
-      pageParam: 2,
-      meta: undefined,
-      direction: 'forward',
-      signal: abortSignal,
-    })
-
-    queryFnSpy = vi.fn().mockImplementation(({ pageParam = 1, signal }) => {
-      abortSignal = signal
-      sleep(10)
-      return pageParam
-    })
-
-    // Refetch the query
-    observer.refetch()
-    expect(observerResult).toMatchObject({
-      isFetching: true,
-      isError: false,
-    })
-
-    // Cancel the query
-    const query = observer.getCurrentQuery()
-    query.cancel()
-
-    expect(observerResult).toMatchObject({
-      isFetching: false,
-      isError: true,
-      error: new CancelledError(),
-      data: { pages: [1, 2], pageParams: [1, 2] },
-    })
-
-    // Pages should not have been fetched
-    expect(queryFnSpy).toHaveBeenCalledTimes(0)
-
-    unsubscribe()
-  })
-
-  test('InfiniteQueryBehavior should not enter an infinite loop when a page errors while retry is on #8046', async () => {
-    let errorCount = 0
-    const key = queryKey()
-
-    interface TestResponse {
-      data: Array<{ id: string }>
-      nextToken?: number
-    }
-
-    const fakeData = [
-      { data: [{ id: 'item-1' }], nextToken: 1 },
-      { data: [{ id: 'item-2' }], nextToken: 2 },
-      { data: [{ id: 'item-3' }], nextToken: 3 },
-      { data: [{ id: 'item-4' }] },
-    ]
-
-    const fetchData = async ({ nextToken = 0 }: { nextToken?: number }) =>
-      new Promise<TestResponse>((resolve, reject) => {
-        setTimeout(() => {
-          if (nextToken == 2 && errorCount < 3) {
-            errorCount += 1
-            reject({ statusCode: 429 })
-            return
-          }
-          resolve(fakeData[nextToken] as TestResponse)
-        }, 10)
-      })
-
-    const observer = new InfiniteQueryObserver<
-      TestResponse,
-      Error,
-      InfiniteData<TestResponse>,
-      TestResponse,
-      typeof key,
-      number
-    >(queryClient, {
-      retry: 5,
-      staleTime: 0,
-      retryDelay: 10,
-
-      queryKey: key,
-      initialPageParam: 1,
-      getNextPageParam: (lastPage) => lastPage.nextToken,
-      queryFn: ({ pageParam }) => fetchData({ nextToken: pageParam }),
-    })
-
-    // Fetch Page 1
-    const page1Data = await observer.fetchNextPage()
-    expect(page1Data.data?.pageParams).toEqual([1])
-
-    // Fetch Page 2, as per the queryFn, this will reject 2 times then resolves
-    const page2Data = await observer.fetchNextPage()
-    expect(page2Data.data?.pageParams).toEqual([1, 2])
-
-    // Fetch Page 3
-    const page3Data = await observer.fetchNextPage()
-    expect(page3Data.data?.pageParams).toEqual([1, 2, 3])
-
-    // Now the real deal; re-fetching this query **should not** stamp into an
-    // infinite loop where the retryer every time restarts from page 1
-    // once it reaches the page where it errors.
-    // For this to work, we'd need to reset the error count so we actually retry
-    errorCount = 0
-    const reFetchedData = await observer.refetch()
-
-    expect(reFetchedData.data?.pageParams).toEqual([1, 2, 3])
-  })
-
-  test('should fetch even if initialPageParam is null', async () => {
-    const key = queryKey()
-
-    const observer = new InfiniteQueryObserver(queryClient, {
-      queryKey: key,
-      queryFn: async () => 'data',
-      getNextPageParam: () => null,
-      initialPageParam: null,
-    })
-
-    let observerResult:
-      | InfiniteQueryObserverResult<unknown, unknown>
-      | undefined
-
-    const unsubscribe = observer.subscribe((result) => {
-      observerResult = result
-    })
-
-    await waitFor(() =>
-      expect(observerResult).toMatchObject({
-        isFetching: false,
-        data: { pages: ['data'], pageParams: [null] },
-      }),
-    )
-
-    unsubscribe()
-  })
-})

package/src/__tests__/infiniteQueryObserver.test-d.tsx

@@ -1,64 +0,0 @@
-import { afterEach, beforeEach, describe, expectTypeOf, it, vi } from 'vitest'
-import { InfiniteQueryObserver } from '..'
-import { createQueryClient, queryKey } from './utils'
-import type { InfiniteData, QueryClient } from '..'
-
-describe('InfiniteQueryObserver', () => {
-  let queryClient: QueryClient
-
-  beforeEach(() => {
-    queryClient = createQueryClient()
-    queryClient.mount()
-  })
-
-  afterEach(() => {
-    queryClient.clear()
-  })
-
-  it('should be inferred as a correct result type', async () => {
-    const next: number | undefined = 2
-    const queryFn = vi.fn(({ pageParam }) => String(pageParam))
-    const observer = new InfiniteQueryObserver(queryClient, {
-      queryKey: queryKey(),
-      queryFn,
-      initialPageParam: 1,
-      getNextPageParam: () => next,
-    })
-
-    const result = observer.getCurrentResult()
-
-    if (result.isPending) {
-      expectTypeOf(result.data).toEqualTypeOf<undefined>()
-      expectTypeOf(result.error).toEqualTypeOf<null>()
-      expectTypeOf(result.isLoading).toEqualTypeOf<boolean>()
-      expectTypeOf(result.status).toEqualTypeOf<'pending'>()
-    }
-
-    if (result.isLoading) {
-      expectTypeOf(result.data).toEqualTypeOf<undefined>()
-      expectTypeOf(result.error).toEqualTypeOf<null>()
-      expectTypeOf(result.isPending).toEqualTypeOf<true>()
-      expectTypeOf(result.status).toEqualTypeOf<'pending'>()
-    }
-
-    if (result.isLoadingError) {
-      expectTypeOf(result.data).toEqualTypeOf<undefined>()
-      expectTypeOf(result.error).toEqualTypeOf<Error>()
-      expectTypeOf(result.status).toEqualTypeOf<'error'>()
-    }
-
-    if (result.isRefetchError) {
-      expectTypeOf(result.data).toEqualTypeOf<InfiniteData<string, unknown>>()
-      expectTypeOf(result.error).toEqualTypeOf<Error>()
-      expectTypeOf(result.status).toEqualTypeOf<'error'>()
-      expectTypeOf(result.isFetchNextPageError).toEqualTypeOf<boolean>()
-      expectTypeOf(result.isFetchPreviousPageError).toEqualTypeOf<boolean>()
-    }
-
-    if (result.isSuccess) {
-      expectTypeOf(result.data).toEqualTypeOf<InfiniteData<string, unknown>>()
-      expectTypeOf(result.error).toEqualTypeOf<null>()
-      expectTypeOf(result.status).toEqualTypeOf<'success'>()
-    }
-  })
-})

package/src/__tests__/infiniteQueryObserver.test.tsx

@@ -1,198 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest'
-import { InfiniteQueryObserver } from '..'
-import { createQueryClient, queryKey, sleep } from './utils'
-import type { QueryClient } from '..'
-
-describe('InfiniteQueryObserver', () => {
-  let queryClient: QueryClient
-
-  beforeEach(() => {
-    queryClient = createQueryClient()
-    queryClient.mount()
-  })
-
-  afterEach(() => {
-    queryClient.clear()
-  })
-
-  test('InfiniteQueryObserver should be able to fetch an infinite query with selector', async () => {
-    const key = queryKey()
-    const observer = new InfiniteQueryObserver(queryClient, {
-      queryKey: key,
-      queryFn: () => 1,
-      select: (data) => ({
-        pages: data.pages.map((x) => `${x}`),
-        pageParams: data.pageParams,
-      }),
-      initialPageParam: 1,
-      getNextPageParam: () => 2,
-    })
-    let observerResult
-    const unsubscribe = observer.subscribe((result) => {
-      observerResult = result
-    })
-    await sleep(1)
-    unsubscribe()
-    expect(observerResult).toMatchObject({
-      data: { pages: ['1'], pageParams: [1] },
-    })
-  })
-
-  test('InfiniteQueryObserver should pass the meta option to the queryFn', async () => {
-    const meta = {
-      it: 'works',
-    }
-
-    const key = queryKey()
-    const queryFn = vi.fn(() => 1)
-    const observer = new InfiniteQueryObserver(queryClient, {
-      meta,
-      queryKey: key,
-      queryFn,
-      select: (data) => ({
-        pages: data.pages.map((x) => `${x}`),
-        pageParams: data.pageParams,
-      }),
-      initialPageParam: 1,
-      getNextPageParam: () => 2,
-    })
-    let observerResult
-    const unsubscribe = observer.subscribe((result) => {
-      observerResult = result
-    })
-    await sleep(1)
-    unsubscribe()
-    expect(observerResult).toMatchObject({
-      data: { pages: ['1'], pageParams: [1] },
-    })
-    expect(queryFn).toBeCalledWith(expect.objectContaining({ meta }))
-  })
-
-  test('getNextPagParam and getPreviousPageParam should receive current pageParams', async () => {
-    const key = queryKey()
-    let single: Array<string> = []
-    let all: Array<string> = []
-    const observer = new InfiniteQueryObserver(queryClient, {
-      queryKey: key,
-      queryFn: ({ pageParam }) => String(pageParam),
-      initialPageParam: 1,
-      getNextPageParam: (_, __, lastPageParam, allPageParams) => {
-        single.push('next' + lastPageParam)
-        all.push('next' + allPageParams.join(','))
-        return lastPageParam + 1
-      },
-      getPreviousPageParam: (_, __, firstPageParam, allPageParams) => {
-        single.push('prev' + firstPageParam)
-        all.push('prev' + allPageParams.join(','))
-        return firstPageParam - 1
-      },
-    })
-
-    await observer.fetchNextPage()
-    await observer.fetchPreviousPage()
-
-    expect(single).toEqual(['next1', 'prev1', 'prev1', 'next1', 'prev0'])
-    expect(all).toEqual(['next1', 'prev1', 'prev1', 'next0,1', 'prev0,1'])
-
-    single = []
-    all = []
-
-    await observer.refetch()
-
-    expect(single).toEqual(['next0', 'next1', 'prev0'])
-    expect(all).toEqual(['next0', 'next0,1', 'prev0,1'])
-  })
-
-  test('should not invoke getNextPageParam and getPreviousPageParam on empty pages', async () => {
-    const key = queryKey()
-
-    const getNextPageParam = vi.fn()
-    const getPreviousPageParam = vi.fn()
-
-    const observer = new InfiniteQueryObserver(queryClient, {
-      queryKey: key,
-      queryFn: ({ pageParam }) => String(pageParam),
-      initialPageParam: 1,
-      getNextPageParam: getNextPageParam.mockImplementation(
-        (_, __, lastPageParam) => {
-          return lastPageParam + 1
-        },
-      ),
-      getPreviousPageParam: getPreviousPageParam.mockImplementation(
-        (_, __, firstPageParam) => {
-          return firstPageParam - 1
-        },
-      ),
-    })
-
-    const unsubscribe = observer.subscribe(() => {})
-
-    getNextPageParam.mockClear()
-    getPreviousPageParam.mockClear()
-
-    queryClient.setQueryData(key, { pages: [], pageParams: [] })
-
-    expect(getNextPageParam).toHaveBeenCalledTimes(0)
-    expect(getPreviousPageParam).toHaveBeenCalledTimes(0)
-
-    unsubscribe()
-  })
-
-  test('should stop refetching if undefined is returned from getNextPageParam', async () => {
-    const key = queryKey()
-    let next: number | undefined = 2
-    const queryFn = vi.fn<(...args: Array<any>) => any>(({ pageParam }) =>
-      String(pageParam),
-    )
-    const observer = new InfiniteQueryObserver(queryClient, {
-      queryKey: key,
-      queryFn,
-      initialPageParam: 1,
-      getNextPageParam: () => next,
-    })
-
-    await observer.fetchNextPage()
-    await observer.fetchNextPage()
-
-    expect(observer.getCurrentResult().data?.pages).toEqual(['1', '2'])
-    expect(queryFn).toBeCalledTimes(2)
-    expect(observer.getCurrentResult().hasNextPage).toBe(true)
-
-    next = undefined
-
-    await observer.refetch()
-
-    expect(observer.getCurrentResult().data?.pages).toEqual(['1'])
-    expect(queryFn).toBeCalledTimes(3)
-    expect(observer.getCurrentResult().hasNextPage).toBe(false)
-  })
-
-  test('should stop refetching if null is returned from getNextPageParam', async () => {
-    const key = queryKey()
-    let next: number | null = 2
-    const queryFn = vi.fn<(...args: Array<any>) => any>(({ pageParam }) =>
-      String(pageParam),
-    )
-    const observer = new InfiniteQueryObserver(queryClient, {
-      queryKey: key,
-      queryFn,
-      initialPageParam: 1,
-      getNextPageParam: () => next,
-    })
-
-    await observer.fetchNextPage()
-    await observer.fetchNextPage()
-
-    expect(observer.getCurrentResult().data?.pages).toEqual(['1', '2'])
-    expect(queryFn).toBeCalledTimes(2)
-    expect(observer.getCurrentResult().hasNextPage).toBe(true)
-
-    next = null
-
-    await observer.refetch()
-
-    expect(observer.getCurrentResult().data?.pages).toEqual(['1'])
-    expect(queryFn).toBeCalledTimes(3)
-    expect(observer.getCurrentResult().hasNextPage).toBe(false)
-  })
-})