@tanstack/query-core 5.0.0-alpha.81 → 5.0.0-alpha.85

package/src/retryer.ts

@@ -1,7 +1,7 @@
 import { focusManager } from './focusManager'
 import { onlineManager } from './onlineManager'
 import { sleep } from './utils'
-import type { CancelOptions, NetworkMode, DefaultError } from './types'
+import type { CancelOptions, DefaultError, NetworkMode } from './types'
 
 // TYPES
 

package/src/tests/focusManager.test.tsx

@@ -1,7 +1,7 @@
+import { vi } from 'vitest'
 import { sleep } from '../utils'
 import { FocusManager } from '../focusManager'
 import { setIsServer } from './utils'
-import { vi } from 'vitest'
 
 describe('focusManager', () => {
   let focusManager: FocusManager

package/src/tests/hydration.test.tsx

@@ -1,12 +1,13 @@
+import { expect, vi } from 'vitest'
+import { QueryCache } from '../queryCache'
+import { dehydrate, hydrate } from '../hydration'
+import { MutationCache } from '../mutationCache'
 import {
   createQueryClient,
   executeMutation,
   mockNavigatorOnLine,
   sleep,
 } from './utils'
-import { QueryCache } from '../queryCache'
-import { dehydrate, hydrate } from '../hydration'
-import { vi } from 'vitest'
 
 async function fetchData<TData>(value: TData, ms?: number): Promise<TData> {
   await sleep(ms || 0)
@@ -557,4 +558,114 @@ describe('dehydration and rehydration', () => {
       hydrationCache.find({ queryKey: ['string'] })?.state.fetchStatus,
     ).toBe('idle')
   })
+
+  test('should dehydrate and hydrate meta for queries', async () => {
+    const queryCache = new QueryCache()
+    const queryClient = createQueryClient({ queryCache })
+    await queryClient.prefetchQuery({
+      queryKey: ['meta'],
+      queryFn: () => Promise.resolve('meta'),
+      meta: {
+        some: 'meta',
+      },
+    })
+    await queryClient.prefetchQuery({
+      queryKey: ['no-meta'],
+      queryFn: () => Promise.resolve('no-meta'),
+    })
+
+    const dehydrated = dehydrate(queryClient)
+
+    expect(
+      dehydrated.queries.find((q) => q.queryHash === '["meta"]')?.meta,
+    ).toEqual({
+      some: 'meta',
+    })
+
+    expect(
+      dehydrated.queries.find((q) => q.queryHash === '["no-meta"]')?.meta,
+    ).toEqual(undefined)
+
+    expect(
+      Object.keys(
+        dehydrated.queries.find((q) => q.queryHash === '["no-meta"]')!,
+      ),
+    ).not.toEqual(expect.arrayContaining(['meta']))
+
+    const stringified = JSON.stringify(dehydrated)
+
+    // ---
+
+    const parsed = JSON.parse(stringified)
+    const hydrationCache = new QueryCache()
+    const hydrationClient = createQueryClient({
+      queryCache: hydrationCache,
+    })
+    hydrate(hydrationClient, parsed)
+    expect(hydrationCache.find({ queryKey: ['meta'] })?.meta).toEqual({
+      some: 'meta',
+    })
+    expect(hydrationCache.find({ queryKey: ['no-meta'] })?.meta).toEqual(
+      undefined,
+    )
+  })
+
+  test('should dehydrate and hydrate meta for mutations', async () => {
+    const mutationCache = new MutationCache()
+    const queryClient = createQueryClient({ mutationCache })
+
+    await executeMutation(
+      queryClient,
+      {
+        mutationKey: ['meta'],
+        mutationFn: () => Promise.resolve('meta'),
+        meta: {
+          some: 'meta',
+        },
+      },
+      undefined,
+    )
+
+    await executeMutation(
+      queryClient,
+      {
+        mutationKey: ['no-meta'],
+        mutationFn: () => Promise.resolve('no-meta'),
+      },
+      undefined,
+    )
+
+    const dehydrated = dehydrate(queryClient, {
+      shouldDehydrateMutation: () => true,
+    })
+
+    expect(Object.keys(dehydrated.mutations[0]!)).toEqual(
+      expect.arrayContaining(['meta']),
+    )
+    expect(dehydrated.mutations[0]?.meta).toEqual({
+      some: 'meta',
+    })
+
+    expect(Object.keys(dehydrated.mutations[1]!)).not.toEqual(
+      expect.arrayContaining(['meta']),
+    )
+    expect(dehydrated.mutations[1]?.meta).toEqual(undefined)
+
+    const stringified = JSON.stringify(dehydrated)
+
+    // ---
+
+    const parsed = JSON.parse(stringified)
+    const hydrationCache = new MutationCache()
+    const hydrationClient = createQueryClient({
+      mutationCache: hydrationCache,
+    })
+    hydrate(hydrationClient, parsed)
+    expect(hydrationCache.find({ mutationKey: ['meta'] })?.meta).toEqual({
+      some: 'meta',
+    })
+    expect(hydrationCache.find({ mutationKey: ['no-meta'] })?.meta).toEqual(
+      undefined,
+    )
+  })
 })

package/src/tests/infiniteQueryBehavior.test.tsx

@@ -1,8 +1,8 @@
 import { waitFor } from '@testing-library/react'
-import type { QueryClient, QueryCache, InfiniteQueryObserverResult } from '..'
-import { InfiniteQueryObserver, CancelledError } from '..'
-import { createQueryClient, queryKey, sleep } from './utils'
 import { vi } from 'vitest'
+import { CancelledError, InfiniteQueryObserver } from '..'
+import { createQueryClient, queryKey, sleep } from './utils'
+import type { InfiniteQueryObserverResult, QueryCache, QueryClient } from '..'
 
 describe('InfiniteQueryBehavior', () => {
   let queryClient: QueryClient

package/src/tests/infiniteQueryObserver.test.tsx

@@ -1,7 +1,7 @@
+import { vi } from 'vitest'
+import { InfiniteQueryObserver } from '..'
 import { createQueryClient, queryKey, sleep } from './utils'
 import type { QueryClient } from '..'
-import { InfiniteQueryObserver } from '..'
-import { vi } from 'vitest'
 
 describe('InfiniteQueryObserver', () => {
   let queryClient: QueryClient

package/src/tests/mutationCache.test.tsx

@@ -1,7 +1,7 @@
 import { waitFor } from '@testing-library/react'
-import { queryKey, sleep, executeMutation, createQueryClient } from './utils'
-import { MutationCache, MutationObserver } from '..'
 import { vi } from 'vitest'
+import { MutationCache, MutationObserver } from '..'
+import { createQueryClient, executeMutation, queryKey, sleep } from './utils'
 
 describe('mutationCache', () => {
   describe('MutationCacheConfig error callbacks', () => {

package/src/tests/mutationObserver.test.tsx

@@ -1,8 +1,8 @@
 import { waitFor } from '@testing-library/react'
+import { vi } from 'vitest'
+import { MutationObserver } from '..'
 import { createQueryClient, sleep } from './utils'
 import type { QueryClient } from '..'
-import { MutationObserver } from '..'
-import { vi } from 'vitest'
 
 describe('mutationObserver', () => {
   let queryClient: QueryClient

package/src/tests/mutations.test.tsx

@@ -1,9 +1,9 @@
-import type { QueryClient } from '..'
-import { createQueryClient, executeMutation, queryKey, sleep } from './utils'
-import type { MutationState } from '../mutation'
-import { MutationObserver } from '../mutationObserver'
 import { vi } from 'vitest'
 import { waitFor } from '@testing-library/react'
+import { MutationObserver } from '../mutationObserver'
+import { createQueryClient, executeMutation, queryKey, sleep } from './utils'
+import type { QueryClient } from '..'
+import type { MutationState } from '../mutation'
 
 describe('mutations', () => {
   let queryClient: QueryClient

package/src/tests/notifyManager.test.tsx

@@ -1,6 +1,6 @@
+import { vi } from 'vitest'
 import { createNotifyManager } from '../notifyManager'
 import { sleep } from './utils'
-import { vi } from 'vitest'
 
 describe('notifyManager', () => {
   it('should use default notifyFn', async () => {

package/src/tests/onlineManager.test.tsx

@@ -1,6 +1,6 @@
+import { vi } from 'vitest'
 import { OnlineManager } from '../onlineManager'
 import { setIsServer, sleep } from './utils'
-import { vi } from 'vitest'
 
 describe('onlineManager', () => {
   let onlineManager: OnlineManager

package/src/tests/queriesObserver.test.tsx

@@ -1,8 +1,8 @@
 import { waitFor } from '@testing-library/react'
-import { sleep, queryKey, createQueryClient } from './utils'
-import type { QueryClient, QueryObserverResult } from '..'
-import { QueriesObserver } from '..'
 import { vi } from 'vitest'
+import { QueriesObserver } from '..'
+import { createQueryClient, queryKey, sleep } from './utils'
+import type { QueryClient, QueryObserverResult } from '..'
 
 describe('queriesObserver', () => {
   let queryClient: QueryClient

package/src/tests/query.test.tsx

@@ -1,8 +1,11 @@
+import { waitFor } from '@testing-library/react'
+import { vi } from 'vitest'
+import { QueryObserver, isCancelledError, onlineManager } from '..'
 import {
-  sleep,
-  queryKey,
-  mockVisibilityState,
   createQueryClient,
+  mockVisibilityState,
+  queryKey,
+  sleep,
 } from './utils'
 import type {
   QueryCache,
@@ -10,9 +13,6 @@ import type {
   QueryFunctionContext,
   QueryObserverResult,
 } from '..'
-import { QueryObserver, isCancelledError, onlineManager } from '..'
-import { waitFor } from '@testing-library/react'
-import { vi } from 'vitest'
 
 describe('query', () => {
   let queryClient: QueryClient

package/src/tests/queryCache.test.tsx

@@ -1,7 +1,7 @@
-import { sleep, queryKey, createQueryClient } from './utils'
-import { QueryClient, QueryCache, QueryObserver } from '..'
 import { waitFor } from '@testing-library/react'
 import { vi } from 'vitest'
+import { QueryCache, QueryClient, QueryObserver } from '..'
+import { createQueryClient, queryKey, sleep } from './utils'
 
 describe('queryCache', () => {
   let queryClient: QueryClient

package/src/tests/queryClient.test.tsx

@@ -1,11 +1,19 @@
 import { waitFor } from '@testing-library/react'
 import '@testing-library/jest-dom'
 
+import { vi } from 'vitest'
+import {
+  MutationObserver,
+  QueryObserver,
+  focusManager,
+  onlineManager,
+} from '..'
+import { noop } from '../utils'
 import {
-  sleep,
-  queryKey,
   createQueryClient,
   mockNavigatorOnLine,
+  queryKey,
+  sleep,
 } from './utils'
 import type {
   QueryCache,
@@ -13,14 +21,6 @@ import type {
   QueryFunction,
   QueryObserverOptions,
 } from '..'
-import {
-  MutationObserver,
-  QueryObserver,
-  focusManager,
-  onlineManager,
-} from '..'
-import { noop } from '../utils'
-import { vi } from 'vitest'
 
 describe('queryClient', () => {
   let queryClient: QueryClient

package/src/tests/queryObserver.test.tsx

@@ -1,7 +1,7 @@
-import { sleep, queryKey, expectType, createQueryClient } from './utils'
-import type { QueryClient, QueryObserverResult } from '..'
-import { QueryObserver, focusManager } from '..'
 import { vi } from 'vitest'
+import { QueryObserver, focusManager } from '..'
+import { createQueryClient, expectType, queryKey, sleep } from './utils'
+import type { QueryClient, QueryObserverResult } from '..'
 
 describe('queryObserver', () => {
   let queryClient: QueryClient

package/src/tests/utils.test.tsx

@@ -1,17 +1,17 @@
+import { vi } from 'vitest'
 import {
-  replaceEqualDeep,
-  partialMatchKey,
+  addToEnd,
+  addToStart,
+  isPlainArray,
   isPlainObject,
   matchMutation,
+  partialMatchKey,
+  replaceEqualDeep,
   scheduleMicrotask,
   sleep,
-  isPlainArray,
-  addToEnd,
-  addToStart,
 } from '../utils'
 import { Mutation } from '../mutation'
 import { createQueryClient } from './utils'
-import { vi } from 'vitest'
 
 describe('core/utils', () => {
   describe('isPlainObject', () => {

package/src/tests/utils.ts

@@ -1,19 +1,21 @@
 import { act } from '@testing-library/react'
 import { vi } from 'vitest'
-
-import type { MutationOptions, QueryClientConfig } from '..'
 import { QueryClient } from '..'
 import * as utils from '../utils'
+import type { SpyInstance } from 'vitest'
+import type { MutationOptions, QueryClientConfig } from '..'
 
 export function createQueryClient(config?: QueryClientConfig): QueryClient {
   return new QueryClient(config)
 }
 
-export function mockVisibilityState(value: DocumentVisibilityState) {
+export function mockVisibilityState(
+  value: DocumentVisibilityState,
+): SpyInstance<[], DocumentVisibilityState> {
   return vi.spyOn(document, 'visibilityState', 'get').mockReturnValue(value)
 }
 
-export function mockNavigatorOnLine(value: boolean) {
+export function mockNavigatorOnLine(value: boolean): SpyInstance<[], boolean> {
   return vi.spyOn(navigator, 'onLine', 'get').mockReturnValue(value)
 }
 

package/src/types.ts

@@ -1,8 +1,8 @@
 /* istanbul ignore file */
 
 import type { MutationState } from './mutation'
-import type { FetchDirection, QueryBehavior, Query } from './query'
-import type { RetryValue, RetryDelayValue } from './retryer'
+import type { FetchDirection, Query, QueryBehavior } from './query'
+import type { RetryDelayValue, RetryValue } from './retryer'
 import type { QueryFilters, QueryTypeFilter } from './utils'
 import type { QueryCache } from './queryCache'
 import type { MutationCache } from './mutationCache'