@tanstack/solid-query 5.101.4 → 5.102.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-query",
-  "version": "5.101.4",
+  "version": "5.102.1",
   "description": "Primitives for managing, caching and syncing asynchronous and remote data in Solid",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -46,13 +46,13 @@
     "!src/__tests__"
   ],
   "dependencies": {
-    "@tanstack/query-core": "5.101.4"
+    "@tanstack/query-core": "5.102.1"
   },
   "devDependencies": {
     "@solidjs/testing-library": "^0.8.10",
     "npm-run-all2": "^5.0.0",
     "solid-js": "^1.9.7",
-    "tsup-preset-solid": "^2.2.0",
+    "unplugin-solid": "^2.0.0",
     "vite-plugin-solid": "^2.11.6",
     "@tanstack/query-test-utils": "0.0.0"
   },
@@ -64,18 +64,16 @@
     "compile": "tsc --build",
     "test:eslint": "eslint --concurrency=auto ./src",
     "test:types": "npm-run-all --serial test:types:*",
-    "test:types:ts54": "node ../../node_modules/typescript54/lib/tsc.js --build tsconfig.legacy.json",
-    "test:types:ts55": "node ../../node_modules/typescript55/lib/tsc.js --build tsconfig.legacy.json",
     "test:types:ts56": "node ../../node_modules/typescript56/lib/tsc.js --build tsconfig.legacy.json",
     "test:types:ts57": "node ../../node_modules/typescript57/lib/tsc.js --build tsconfig.legacy.json",
     "test:types:ts58": "node ../../node_modules/typescript58/lib/tsc.js --build tsconfig.legacy.json",
     "test:types:ts59": "node ../../node_modules/typescript59/lib/tsc.js --build tsconfig.legacy.json",
     "test:types:tscurrent": "tsc --build",
-    "test:types:ts60": "node ../../node_modules/typescript60/lib/tsc.js --build tsconfig.legacy.json",
+    "test:types:ts70": "node ../../node_modules/typescript70/lib/tsc.js --build tsconfig.legacy.json",
     "test:lib": "vitest --retry=3",
     "test:lib:dev": "pnpm run test:lib --watch",
     "test:build": "publint --strict && attw --pack",
-    "build": "tsup --tsconfig tsconfig.prod.json",
-    "build:watch": "tsup --watch"
+    "build": "tsdown --tsconfig tsconfig.prod.json",
+    "build:watch": "tsdown --watch"
   }
 }

package/src/QueryClientProvider.tsx

@@ -5,12 +5,15 @@ import {
   useContext,
 } from 'solid-js'
 import type { QueryClient } from './QueryClient'
-import type { JSX } from 'solid-js'
+import type { Accessor, JSX } from 'solid-js'
 
 export const QueryClientContext = createContext<
   (() => QueryClient) | undefined
 >(undefined)
 
+const queryClientContextError =
+  'No QueryClient set, use QueryClientProvider to set one'
+
 export const useQueryClient = (queryClient?: QueryClient) => {
   if (queryClient) {
     return queryClient
@@ -18,12 +21,31 @@ export const useQueryClient = (queryClient?: QueryClient) => {
   const client = useContext(QueryClientContext)
 
   if (!client) {
-    throw new Error('No QueryClient set, use QueryClientProvider to set one')
+    throw new Error(queryClientContextError)
   }
 
   return client()
 }
 
+export const useQueryClientResolver = (
+  queryClient?: Accessor<QueryClient | undefined>,
+): Accessor<QueryClient> => {
+  const contextClient = useContext(QueryClientContext)
+
+  return () => {
+    const resolvedClient = queryClient?.()
+    if (resolvedClient) {
+      return resolvedClient
+    }
+
+    if (!contextClient) {
+      throw new Error(queryClientContextError)
+    }
+
+    return contextClient()
+  }
+}
+
 export type QueryClientProviderProps = {
   client: QueryClient
   children?: JSX.Element

package/src/infiniteQueryOptions.ts

@@ -1,9 +1,9 @@
 import type {
-  DataTag,
   DefaultError,
   InfiniteData,
   NonUndefinedGuard,
   QueryKey,
+  QueryKeyWithDataTag,
 } from '@tanstack/query-core'
 import type { InfiniteQueryOptions } from './types'
 import type { Accessor } from 'solid-js'
@@ -58,9 +58,8 @@ export function infiniteQueryOptions<
     TQueryKey,
     TPageParam
   >
-> & {
-  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>
-}
+> &
+  QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>
 export function infiniteQueryOptions<
   TQueryFnData,
   TError = DefaultError,
@@ -85,9 +84,8 @@ export function infiniteQueryOptions<
     TQueryKey,
     TPageParam
   >
-> & {
-  queryKey: DataTag<TQueryKey, InfiniteData<TQueryFnData>>
-}
+> &
+  QueryKeyWithDataTag<TQueryKey, InfiniteData<TQueryFnData>, TError>
 
 export function infiniteQueryOptions(options: unknown) {
   return options

package/src/queryOptions.ts

@@ -1,4 +1,8 @@
-import type { DataTag, DefaultError, QueryKey } from '@tanstack/query-core'
+import type {
+  DefaultError,
+  QueryKey,
+  QueryKeyWithDataTag,
+} from '@tanstack/query-core'
 import type { QueryOptions } from './types'
 import type { Accessor } from 'solid-js'
 
@@ -35,9 +39,8 @@ export function queryOptions<
   >,
 ): ReturnType<
   UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>
-> & {
-  queryKey: DataTag<TQueryKey, TQueryFnData, TError>
-}
+> &
+  QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>
 
 export function queryOptions<
   TQueryFnData = unknown,
@@ -50,9 +53,8 @@ export function queryOptions<
   >,
 ): ReturnType<
   DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>
-> & {
-  queryKey: DataTag<TQueryKey, TQueryFnData, TError>
-}
+> &
+  QueryKeyWithDataTag<TQueryKey, TQueryFnData, TError>
 
 export function queryOptions(options: unknown) {
   return options

package/src/useBaseQuery.ts

@@ -12,7 +12,7 @@ import {
   onCleanup,
 } from 'solid-js'
 import { createStore, reconcile, unwrap } from 'solid-js/store'
-import { useQueryClient } from './QueryClientProvider'
+import { useQueryClientResolver } from './QueryClientProvider'
 import { useIsRestoring } from './isRestoring'
 import type { UseBaseQueryOptions } from './types'
 import type { Accessor, Signal } from 'solid-js'
@@ -115,7 +115,8 @@ export function useBaseQuery<
 ) {
   type ResourceData = QueryObserverResult<TData, TError>
 
-  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const resolveClient = useQueryClientResolver(queryClient)
+  const client = createMemo(() => resolveClient())
   const isRestoring = useIsRestoring()
   // There are times when we run a query on the server but the resource is never read
   // This could lead to times when the queryObserver is unsubscribed before the resource has loaded
@@ -132,9 +133,6 @@ export function useBaseQuery<
     if (isServer) {
       defaultOptions.retry = false
       defaultOptions.throwOnError = true
-      // Enable prefetch during render for SSR - required for createResource to work
-      // Without this, queries wait for effects which never run on the server
-      defaultOptions.experimental_prefetchInRender = true
     }
     return defaultOptions
   })

package/src/useIsFetching.ts

@@ -1,5 +1,5 @@
-import { createMemo, createSignal, onCleanup } from 'solid-js'
-import { useQueryClient } from './QueryClientProvider'
+import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js'
+import { useQueryClientResolver } from './QueryClientProvider'
 import type { QueryFilters } from '@tanstack/query-core'
 import type { QueryClient } from './QueryClient'
 import type { Accessor } from 'solid-js'
@@ -8,16 +8,21 @@ export function useIsFetching(
   filters?: Accessor<QueryFilters>,
   queryClient?: Accessor<QueryClient>,
 ): Accessor<number> {
-  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const resolveClient = useQueryClientResolver(queryClient)
+  const client = createMemo(() => resolveClient())
   const queryCache = createMemo(() => client().getQueryCache())
 
   const [fetches, setFetches] = createSignal(client().isFetching(filters?.()))
 
-  const unsubscribe = queryCache().subscribe(() => {
+  createEffect(() => {
     setFetches(client().isFetching(filters?.()))
-  })
 
-  onCleanup(unsubscribe)
+    const unsubscribe = queryCache().subscribe(() => {
+      setFetches(client().isFetching(filters?.()))
+    })
+
+    onCleanup(unsubscribe)
+  })
 
   return fetches
 }

package/src/useIsMutating.ts

@@ -1,5 +1,5 @@
-import { createMemo, createSignal, onCleanup } from 'solid-js'
-import { useQueryClient } from './QueryClientProvider'
+import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js'
+import { useQueryClientResolver } from './QueryClientProvider'
 import type { MutationFilters } from '@tanstack/query-core'
 import type { QueryClient } from './QueryClient'
 import type { Accessor } from 'solid-js'
@@ -8,18 +8,23 @@ export function useIsMutating(
   filters?: Accessor<MutationFilters>,
   queryClient?: Accessor<QueryClient>,
 ): Accessor<number> {
-  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const resolveClient = useQueryClientResolver(queryClient)
+  const client = createMemo(() => resolveClient())
   const mutationCache = createMemo(() => client().getMutationCache())
 
   const [mutations, setMutations] = createSignal(
     client().isMutating(filters?.()),
   )
 
-  const unsubscribe = mutationCache().subscribe((_result) => {
+  createEffect(() => {
     setMutations(client().isMutating(filters?.()))
-  })
 
-  onCleanup(unsubscribe)
+    const unsubscribe = mutationCache().subscribe(() => {
+      setMutations(client().isMutating(filters?.()))
+    })
+
+    onCleanup(unsubscribe)
+  })
 
   return mutations
 }

package/src/useMutation.ts

@@ -1,7 +1,7 @@
 import { MutationObserver, noop, shouldThrowError } from '@tanstack/query-core'
 import { createComputed, createMemo, on, onCleanup } from 'solid-js'
 import { createStore } from 'solid-js/store'
-import { useQueryClient } from './QueryClientProvider'
+import { useQueryClientResolver } from './QueryClientProvider'
 import type { DefaultError } from '@tanstack/query-core'
 import type { QueryClient } from './QueryClient'
 import type {
@@ -21,7 +21,8 @@ export function useMutation<
   options: UseMutationOptions<TData, TError, TVariables, TOnMutateResult>,
   queryClient?: Accessor<QueryClient>,
 ): UseMutationResult<TData, TError, TVariables, TOnMutateResult> {
-  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const resolveClient = useQueryClientResolver(queryClient)
+  const client = createMemo(() => resolveClient())
 
   const observer = new MutationObserver<
     TData,
@@ -35,8 +36,8 @@ export function useMutation<
     TError,
     TVariables,
     TOnMutateResult
-  > = (variables, mutateOptions) => {
-    observer.mutate(variables, mutateOptions).catch(noop)
+  > = (...args) => {
+    observer.mutate(args[0] as TVariables, args[1]).catch(noop)
   }
 
   const [state, setState] = createStore<

package/src/useMutationState.ts

@@ -1,6 +1,6 @@
 import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js'
 import { replaceEqualDeep } from '@tanstack/query-core'
-import { useQueryClient } from './QueryClientProvider'
+import { useQueryClientResolver } from './QueryClientProvider'
 import type {
   Mutation,
   MutationCache,
@@ -10,28 +10,54 @@ import type {
 import type { Accessor } from 'solid-js'
 import type { QueryClient } from './QueryClient'
 
-type MutationStateOptions<TResult = MutationState> = {
+type MutationTypeFromResult<TResult> = [TResult] extends [
+  MutationState<
+    infer TData,
+    infer TError,
+    infer TVariables,
+    infer TOnMutateResult
+  >,
+]
+  ? Mutation<TData, TError, TVariables, TOnMutateResult>
+  : Mutation
+
+type MutationStateOptions<
+  TResult = MutationState,
+  TMutation extends Mutation<any, any, any, any> =
+    MutationTypeFromResult<TResult>,
+> = {
   filters?: MutationFilters
-  select?: (mutation: Mutation) => TResult
+  select?: (mutation: TMutation) => TResult
 }
 
-function getResult<TResult = MutationState>(
+function getResult<
+  TResult = MutationState,
+  TMutation extends Mutation<any, any, any, any> =
+    MutationTypeFromResult<TResult>,
+>(
   mutationCache: MutationCache,
-  options: MutationStateOptions<TResult>,
+  options: MutationStateOptions<TResult, TMutation>,
 ): Array<TResult> {
   return mutationCache
     .findAll(options.filters)
     .map(
       (mutation): TResult =>
-        (options.select ? options.select(mutation) : mutation.state) as TResult,
+        (options.select
+          ? options.select(mutation as TMutation)
+          : mutation.state) as TResult,
     )
 }
 
-export function useMutationState<TResult = MutationState>(
-  options: Accessor<MutationStateOptions<TResult>> = () => ({}),
+export function useMutationState<
+  TResult = MutationState,
+  TMutation extends Mutation<any, any, any, any> =
+    MutationTypeFromResult<TResult>,
+>(
+  options: Accessor<MutationStateOptions<TResult, TMutation>> = () => ({}),
   queryClient?: Accessor<QueryClient>,
 ): Accessor<Array<TResult>> {
-  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const resolveClient = useQueryClientResolver(queryClient)
+  const client = createMemo(() => resolveClient())
   const mutationCache = createMemo(() => client().getMutationCache())
 
   const [result, setResult] = createSignal(

package/src/useQueries.ts

@@ -11,7 +11,7 @@ import {
   onCleanup,
   onMount,
 } from 'solid-js'
-import { useQueryClient } from './QueryClientProvider'
+import { useQueryClientResolver } from './QueryClientProvider'
 import { useIsRestoring } from './isRestoring'
 import type { QueryOptions, UseQueryResult } from './types'
 import type { Accessor } from 'solid-js'
@@ -196,7 +196,8 @@ export function useQueries<
   }>,
   queryClient?: Accessor<QueryClient>,
 ): TCombinedResult {
-  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const resolveClient = useQueryClientResolver(queryClient)
+  const client = createMemo(() => resolveClient())
   const isRestoring = useIsRestoring()
 
   const defaultedQueries = createMemo(() =>