@tanstack/solid-query 6.0.0-beta.3 → 6.0.0-beta.5

package/src/mutationOptions.ts

@@ -1,5 +1,5 @@
 import type { DefaultError, WithRequired } from '@tanstack/query-core'
-import type { SolidMutationOptions } from './types'
+import type { MutationOptions } from './types'
 
 export function mutationOptions<
   TData = unknown,
@@ -8,11 +8,11 @@ export function mutationOptions<
   TOnMutateResult = unknown,
 >(
   options: WithRequired<
-    SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+    MutationOptions<TData, TError, TVariables, TOnMutateResult>,
     'mutationKey'
   >,
 ): WithRequired<
-  SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+  MutationOptions<TData, TError, TVariables, TOnMutateResult>,
   'mutationKey'
 >
 export function mutationOptions<
@@ -22,11 +22,11 @@ export function mutationOptions<
   TOnMutateResult = unknown,
 >(
   options: Omit<
-    SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+    MutationOptions<TData, TError, TVariables, TOnMutateResult>,
     'mutationKey'
   >,
 ): Omit<
-  SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+  MutationOptions<TData, TError, TVariables, TOnMutateResult>,
   'mutationKey'
 >
 export function mutationOptions<
@@ -35,7 +35,7 @@ export function mutationOptions<
   TVariables = void,
   TOnMutateResult = unknown,
 >(
-  options: SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>,
-): SolidMutationOptions<TData, TError, TVariables, TOnMutateResult> {
+  options: MutationOptions<TData, TError, TVariables, TOnMutateResult>,
+): MutationOptions<TData, TError, TVariables, TOnMutateResult> {
   return options
 }

package/src/queryOptions.ts

@@ -1,5 +1,5 @@
 import type { DataTag, DefaultError, QueryKey } from '@tanstack/query-core'
-import type { SolidQueryOptions } from './types'
+import type { QueryOptions } from './types'
 import type { Accessor } from 'solid-js'
 
 export type UndefinedInitialDataOptions<
@@ -8,7 +8,7 @@ export type UndefinedInitialDataOptions<
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 > = Accessor<
-  SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+  QueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
     initialData?: undefined
   }
 >
@@ -19,7 +19,7 @@ export type DefinedInitialDataOptions<
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 > = Accessor<
-  SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+  QueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
     initialData: TQueryFnData | (() => TQueryFnData)
   }
 >

package/src/types.ts

@@ -44,7 +44,7 @@ export interface UseBaseQueryOptions<
   suspense?: boolean
 }
 
-export interface SolidQueryOptions<
+export interface QueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
@@ -62,7 +62,7 @@ export type UseQueryOptions<
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>
+> = Accessor<QueryOptions<TQueryFnData, TError, TData, TQueryKey>>
 
 /* --- Create Query and Create Base Query  Types --- */
 
@@ -87,7 +87,7 @@ export type DefinedUseQueryResult<
 > = DefinedUseBaseQueryResult<TData, TError>
 
 /* --- Create Infinite Queries Types --- */
-export interface SolidInfiniteQueryOptions<
+export interface InfiniteQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
@@ -126,7 +126,7 @@ export type UseInfiniteQueryOptions<
   TQueryKey extends QueryKey = QueryKey,
   TPageParam = unknown,
 > = Accessor<
-  SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>
+  InfiniteQueryOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>
 >
 
 export type UseInfiniteQueryResult<
@@ -140,7 +140,7 @@ export type DefinedUseInfiniteQueryResult<
 > = DefinedInfiniteQueryObserverResult<TData, TError>
 
 /* --- Create Mutation Types --- */
-export interface SolidMutationOptions<
+export interface MutationOptions<
   TData = unknown,
   TError = DefaultError,
   TVariables = void,
@@ -155,7 +155,7 @@ export type UseMutationOptions<
   TError = DefaultError,
   TVariables = void,
   TOnMutateResult = unknown,
-> = Accessor<SolidMutationOptions<TData, TError, TVariables, TOnMutateResult>>
+> = Accessor<MutationOptions<TData, TError, TVariables, TOnMutateResult>>
 
 export type UseMutateFunction<
   TData = unknown,

package/src/useBaseQuery.ts

@@ -3,13 +3,14 @@
 // why that happens.
 import { notifyManager, shouldThrowError } from '@tanstack/query-core'
 import {
-  createMemo,
   createRenderEffect,
+  createSignal,
   createStore,
   isPending,
   onCleanup,
   reconcile,
   refresh,
+  runWithOwner,
   snapshot,
   untrack,
 } from 'solid-js'
@@ -151,7 +152,12 @@ export function useBaseQuery<
 ) {
   type ResourceData = QueryObserverResult<TData, TError>
 
-  const client = createMemo(() => useQueryClient(queryClient?.()))
+  // Use createSignal(fn) instead of createMemo so these derived memos have
+  // _preventAutoDisposal set. Without it, a createMemo that no one reads
+  // reactively gets auto-disposed in Solid v2, which cascades and disposes
+  // the component's onCleanup, unsubscribing the observer before the fetch
+  // completes.
+  const [client] = createSignal(() => useQueryClient(queryClient?.()))
   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
@@ -159,7 +165,7 @@ export function useBaseQuery<
   // before the resource has loaded
   let unsubscribeQueued = false
 
-  const defaultedOptions = createMemo(() => {
+  const [defaultedOptions] = createSignal(() => {
     const defaultOptions = client().defaultQueryOptions(options())
     defaultOptions._optimisticResults = isRestoring()
       ? 'isRestoring'
@@ -178,7 +184,7 @@ export function useBaseQuery<
   const observer = untrack(() => new Observer(client(), defaultedOptions()))
 
   // Track options reactively so the queryResource memo re-runs on change.
-  const trackedDefaultedOptions = createMemo(() => defaultedOptions())
+  const [trackedDefaultedOptions] = createSignal(() => defaultedOptions())
 
   // Apply options in an effect to avoid store writes inside the memo.
   // setOptions triggers updateResult → notify → subscription → setState,
@@ -186,7 +192,11 @@ export function useBaseQuery<
   createRenderEffect(
     () => trackedDefaultedOptions(),
     (opts) => {
-      observer.setOptions(opts)
+      // observer.setOptions synchronously invokes subscribers which write to
+      // the store. In Solid v2, signal/store writes inside an owned scope
+      // (like this render effect) throw. Escape the owner so subscriber
+      // writes don't trip the guard.
+      runWithOwner(null, () => observer.setOptions(opts))
     },
   )
 
@@ -231,8 +241,8 @@ export function useBaseQuery<
     return observer.subscribe((result) => {
       const previousResult = observerResult
       observerResult = result
-      setStateWithReconciliation(result)
-      queueMicrotask(() => {
+      runWithOwner(null, () => {
+        setStateWithReconciliation(result)
         if (
           unsubscribe &&
           !disposed &&
@@ -243,8 +253,7 @@ export function useBaseQuery<
             refresh(queryResource)
           } catch {
             // NotReadyError is expected when refreshing a memo that returns
-            // a Promise. The Loading boundary handles this during rendering,
-            // but when refresh is called from a microtask there is no boundary.
+            // a Promise. The Loading boundary handles this during rendering.
           }
         }
       })
@@ -280,27 +289,59 @@ export function useBaseQuery<
     but the resource is still in a loading state
   */
   let resolver: ((value: ResourceData) => void) | null = null
-  const queryResource = createMemo<ResourceData>(
-    () => {
-      // Read trackedDefaultedOptions to ensure this memo re-runs when options change
-      const opts = trackedDefaultedOptions()
-      // Read isRestoring unconditionally so the memo re-runs when it changes
-      const restoring = isRestoring()
-
-      return new Promise((resolve, reject) => {
-        resolver = resolve
-        if (isServer) {
-          unsubscribe = createServerSubscriber((data) => {
-            resolve(data as ResourceData)
-          }, reject)
-        } else if (!unsubscribe && !restoring) {
-          unsubscribe = createClientSubscriber()
-        }
-        // Use getOptimisticResult instead of updateResult to keep the memo
-        // free of store writes (updateResult triggers notify → setState).
-        const currentResult = observer.getOptimisticResult(opts)
-        observerResult = currentResult
+  // Use createSignal(fn) instead of createMemo so the derived memo has
+  // _preventAutoDisposal set. Without it, a createMemo that no one reads
+  // reactively gets auto-disposed in Solid v2, which would cascade-dispose
+  // the component's onCleanup and unsubscribe the observer before fetch
+  // completion.
+  const [queryResource] = createSignal<ResourceData>(() => {
+    // Read trackedDefaultedOptions to ensure this memo re-runs when options change
+    const opts = trackedDefaultedOptions()
+    // Read isRestoring unconditionally so the memo re-runs when it changes
+    const restoring = isRestoring()
 
+    if (isServer) {
+      // On retry passes (after the streaming Loading boundary awaits a
+      // pending Promise), the QueryClient cache already has the data, so
+      // `getOptimisticResult` returns a non-loading result synchronously.
+      // Returning the value directly (instead of a fresh Promise that
+      // resolves synchronously) lets Solid's `processResult` set
+      // `comp.value` directly without queueing another async settle. If we
+      // returned a new Promise on every retry, Solid's streaming Loading
+      // boundary `while (ret.p.length)` loop in `createLoadingBoundary`
+      // would never terminate, because each retry adds a new pending
+      // Promise to the boundary's tracked set even when it resolves
+      // synchronously.
+      const cached = observer.getOptimisticResult(opts)
+      if (!cached.isLoading) {
+        observerResult = cached
+        runWithOwner(null, () => {
+          setStateWithReconciliation(cached)
+        })
+        return hydratableObserverResult(
+          observer.getCurrentQuery(),
+          cached,
+        ) as ResourceData
+      }
+    }
+
+    return new Promise<ResourceData>((resolve, reject) => {
+      resolver = resolve
+      if (isServer) {
+        unsubscribe = createServerSubscriber((data) => {
+          resolve(data as ResourceData)
+        }, reject)
+      } else if (!unsubscribe && !restoring) {
+        unsubscribe = createClientSubscriber()
+      }
+      // Use getOptimisticResult instead of updateResult to keep the memo
+      // free of store writes (updateResult triggers notify → setState).
+      const currentResult = observer.getOptimisticResult(opts)
+      observerResult = currentResult
+
+      // Store writes inside a memo's owned scope throw in Solid v2.
+      // Escape the owner so setState calls are allowed.
+      runWithOwner(null, () => {
         if (
           currentResult.isError &&
           !currentResult.isFetching &&
@@ -311,23 +352,31 @@ export function useBaseQuery<
           ])
         ) {
           setStateWithReconciliation(currentResult)
-          return reject(currentResult.error)
+          reject(currentResult.error)
+          return
         }
-        if (!currentResult.isLoading) {
-          resolver = null
-          setStateWithReconciliation(currentResult)
-          return resolve(
-            hydratableObserverResult(observer.getCurrentQuery(), currentResult),
-          )
-        }
-
-        // Defer the loading-state store write so it runs outside the memo.
-        queueMicrotask(() => setStateWithReconciliation(currentResult))
+        setStateWithReconciliation(currentResult)
       })
-    },
-    observerResult,
-    { ssrSource: 'client' },
-  )
+
+      if (
+        currentResult.isError &&
+        !currentResult.isFetching &&
+        !restoring &&
+        shouldThrowError(opts.throwOnError, [
+          currentResult.error,
+          observer.getCurrentQuery(),
+        ])
+      ) {
+        return
+      }
+      if (!currentResult.isLoading) {
+        resolver = null
+        return resolve(
+          hydratableObserverResult(observer.getCurrentQuery(), currentResult),
+        )
+      }
+    })
+  })
 
   onCleanup(() => {
     disposed = true
@@ -364,6 +413,26 @@ export function useBaseQuery<
         return Reflect.get(target, prop, receiver)
       }
 
+      // On the server, force a Suspense dependency on the query resource so
+      // the per-route Loading boundary catches NotReadyError, awaits the
+      // pending Promise, and re-renders with the resolved state. Without
+      // this, JSX reads through the Proxy never subscribe to queryResource
+      // and SSR HTML reflects the initial loading state.
+      //
+      // Read the value from the *resolved resource* rather than `state`. When
+      // the boundary suspends and re-renders after the query settles, the
+      // `state` store is not synced (the server subscriber resolves the
+      // resource Promise but does not write the store), so reading `state`
+      // would render stale loading values. Reading the resolved resource keeps
+      // the streamed SSR HTML consistent with the serialized resource, which
+      // is what the client hydrates against.
+      if (isServer) {
+        const resolved = queryResource()
+        if (prop in resolved) {
+          return Reflect.get(resolved, prop)
+        }
+      }
+
       // Always pass through error-related props without throwing
       if (errorPassthroughProps.has(prop)) {
         return Reflect.get(target, prop, receiver)

package/src/useIsFetching.ts

@@ -13,7 +13,7 @@ export function useIsFetching(
 
   const [fetches, setFetches] = createSignal(
     untrack(() => client().isFetching(filters?.())),
-    { pureWrite: true },
+    { ownedWrite: true },
   )
 
   const unsubscribe = untrack(() =>

package/src/useIsMutating.ts

@@ -13,7 +13,7 @@ export function useIsMutating(
 
   const [mutations, setMutations] = createSignal(
     untrack(() => client().isMutating(filters?.())),
-    { pureWrite: true },
+    { ownedWrite: true },
   )
 
   const unsubscribe = untrack(() =>

package/src/useMutation.ts

@@ -4,6 +4,7 @@ import {
   createRenderEffect,
   createStore,
   onCleanup,
+  runWithOwner,
   untrack,
 } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
@@ -63,11 +64,17 @@ export function useMutation<
   })
 
   const unsubscribe = observer.subscribe((result) => {
-    setState(() => ({
-      ...result,
-      mutate,
-      mutateAsync: result.mutate,
-    }))
+    // observer.mutate may be invoked synchronously from an owned scope (e.g.
+    // during render or inside an effect), which triggers this subscriber
+    // synchronously. Store writes inside an owned scope throw in Solid v2, so
+    // escape the owner to allow the setState write — matching useBaseQuery.
+    runWithOwner(null, () => {
+      setState(() => ({
+        ...result,
+        mutate,
+        mutateAsync: result.mutate,
+      }))
+    })
   })
 
   onCleanup(unsubscribe)

package/src/useMutationState.ts

@@ -36,7 +36,7 @@ export function useMutationState<TResult = MutationState>(
 
   const [result, setResult] = createSignal(
     untrack(() => getResult(mutationCache(), options())),
-    { pureWrite: true },
+    { ownedWrite: true },
   )
 
   const unsubscribe = untrack(() =>

package/src/useQueries.ts

@@ -6,11 +6,12 @@ import {
   merge,
   onCleanup,
   reconcile,
+  runWithOwner,
   untrack,
 } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
 import { useIsRestoring } from './isRestoring'
-import type { SolidQueryOptions, UseQueryResult } from './types'
+import type { QueryOptions, UseQueryResult } from './types'
 import type { Accessor } from 'solid-js'
 import type { QueryClient } from './QueryClient'
 import type {
@@ -33,7 +34,7 @@ type UseQueryOptionsForUseQueries<
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 > = OmitKeyof<
-  SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+  QueryOptions<TQueryFnData, TError, TData, TQueryKey>,
   'placeholderData' | 'suspense'
 > & {
   placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>
@@ -244,14 +245,16 @@ export function useQueries<
     () => {
       if (!isRestoring()) {
         unsubscribe = observer.subscribe((result) => {
-          setState(
-            reconcile(
-              [...result] as Array<QueryObserverResult>,
-              // Use a key function that returns undefined so reconcile
-              // uses positional matching and recursively updates nested properties
-              () => undefined,
-            ),
-          )
+          runWithOwner(null, () => {
+            setState(
+              reconcile(
+                [...result] as Array<QueryObserverResult>,
+                // Use a key function that returns undefined so reconcile
+                // uses positional matching and recursively updates nested properties
+                () => undefined,
+              ),
+            )
+          })
         })
       }
     },
@@ -265,14 +268,16 @@ export function useQueries<
   // Update observer queries when options change reactively
   const trackedDefaultedQueries = createMemo(() => {
     const queries = defaultedQueries()
-    observer.setQueries(
-      queries,
-      queriesOptions().combine
-        ? ({
-            combine: queriesOptions().combine,
-          } as QueriesObserverOptions<TCombinedResult>)
-        : undefined,
-    )
+    runWithOwner(null, () => {
+      observer.setQueries(
+        queries,
+        queriesOptions().combine
+          ? ({
+              combine: queriesOptions().combine,
+            } as QueriesObserverOptions<TCombinedResult>)
+          : undefined,
+      )
+    })
     return queries
   })