@tanstack/solid-query 6.0.0-alpha.1 → 6.0.0-beta.3

package/build/dev.cjs

@@ -107,7 +107,7 @@ function useBaseQuery(options, Observer, queryClient) {
     }
     return defaultOptions;
   });
-  const observer = new Observer(client(), defaultedOptions());
+  const observer = solidJs.untrack(() => new Observer(client(), defaultedOptions()));
   const trackedDefaultedOptions = solidJs.createMemo(() => defaultedOptions());
   solidJs.createRenderEffect(
     () => trackedDefaultedOptions(),
@@ -115,7 +115,9 @@ function useBaseQuery(options, Observer, queryClient) {
       observer.setOptions(opts);
     }
   );
-  let observerResult = observer.getOptimisticResult(defaultedOptions());
+  let observerResult = solidJs.untrack(
+    () => observer.getOptimisticResult(defaultedOptions())
+  );
   const [state, setState] = solidJs.createStore(
     _stripFnsForSSR(observerResult)
   );
@@ -265,17 +267,26 @@ function useInfiniteQuery(options, queryClient) {
 }
 function useMutation(options, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
-  const observer = new queryCore.MutationObserver(client(), options());
-  solidJs.createMemo(() => {
-    observer.setOptions(options());
-  });
+  const observer = solidJs.untrack(
+    () => new queryCore.MutationObserver(
+      client(),
+      options()
+    )
+  );
+  solidJs.createRenderEffect(
+    () => options(),
+    (opts) => {
+      observer.setOptions(opts);
+    }
+  );
   const mutate = (variables, mutateOptions) => {
     observer.mutate(variables, mutateOptions).catch(queryCore.noop);
   };
+  const initialResult = solidJs.untrack(() => observer.getCurrentResult());
   const [state, setState] = solidJs.createStore({
-    ...observer.getCurrentResult(),
+    ...initialResult,
     mutate,
-    mutateAsync: observer.getCurrentResult().mutate
+    mutateAsync: initialResult.mutate
   });
   const unsubscribe = observer.subscribe((result) => {
     setState(() => ({
@@ -310,16 +321,20 @@ function useQueries(queriesOptions, queryClient) {
       })
     )
   );
-  const observer = new queryCore.QueriesObserver(
-    client(),
-    defaultedQueries(),
-    queriesOptions().combine ? {
-      combine: queriesOptions().combine
-    } : void 0
+  const observer = solidJs.untrack(
+    () => new queryCore.QueriesObserver(
+      client(),
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    )
   );
-  const [, getCombinedResult] = observer.getOptimisticResult(
-    defaultedQueries(),
-    queriesOptions().combine
+  const [, getCombinedResult] = solidJs.untrack(
+    () => observer.getOptimisticResult(
+      defaultedQueries(),
+      queriesOptions().combine
+    )
   );
   const initialResult = getCombinedResult();
   const [state, setState] = solidJs.createStore(
@@ -372,10 +387,15 @@ function queryOptions(options) {
 function useIsFetching(filters, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
   const queryCache = solidJs.createMemo(() => client().getQueryCache());
-  const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
-  const unsubscribe = queryCache().subscribe(() => {
-    setFetches(client().isFetching(filters?.()));
-  });
+  const [fetches, setFetches] = solidJs.createSignal(
+    solidJs.untrack(() => client().isFetching(filters?.())),
+    { pureWrite: true }
+  );
+  const unsubscribe = solidJs.untrack(
+    () => queryCache().subscribe(() => {
+      setFetches(client().isFetching(filters?.()));
+    })
+  );
   solidJs.onCleanup(unsubscribe);
   return fetches;
 }
@@ -393,11 +413,14 @@ function useIsMutating(filters, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
   const mutationCache = solidJs.createMemo(() => client().getMutationCache());
   const [mutations, setMutations] = solidJs.createSignal(
-    client().isMutating(filters?.())
+    solidJs.untrack(() => client().isMutating(filters?.())),
+    { pureWrite: true }
+  );
+  const unsubscribe = solidJs.untrack(
+    () => mutationCache().subscribe((_result) => {
+      setMutations(client().isMutating(filters?.()));
+    })
   );
-  const unsubscribe = mutationCache().subscribe((_result) => {
-    setMutations(client().isMutating(filters?.()));
-  });
   solidJs.onCleanup(unsubscribe);
   return mutations;
 }
@@ -410,17 +433,20 @@ function useMutationState(options = () => ({}), queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
   const mutationCache = solidJs.createMemo(() => client().getMutationCache());
   const [result, setResult] = solidJs.createSignal(
-    getResult(mutationCache(), options())
+    solidJs.untrack(() => getResult(mutationCache(), options())),
+    { pureWrite: true }
+  );
+  const unsubscribe = solidJs.untrack(
+    () => mutationCache().subscribe(() => {
+      setResult((prev) => {
+        const nextResult = queryCore.replaceEqualDeep(
+          prev,
+          getResult(mutationCache(), options())
+        );
+        return prev === nextResult ? prev : nextResult;
+      });
+    })
   );
-  const unsubscribe = mutationCache().subscribe(() => {
-    setResult((prev) => {
-      const nextResult = queryCore.replaceEqualDeep(
-        prev,
-        getResult(mutationCache(), options())
-      );
-      return prev === nextResult ? prev : nextResult;
-    });
-  });
   solidJs.onCleanup(unsubscribe);
   return result;
 }

package/build/dev.js

@@ -1,6 +1,6 @@
 import { MutationObserver, shouldThrowError, QueriesObserver, QueryClient as QueryClient$1, replaceEqualDeep, noop, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
-import { createContext, useContext, onCleanup, createMemo, createStore, createRenderEffect, merge, createEffect, reconcile, createSignal, isPending, refresh, snapshot } from 'solid-js';
+import { createContext, useContext, onCleanup, createMemo, untrack, createRenderEffect, createStore, merge, createEffect, reconcile, createSignal, isPending, refresh, snapshot } from 'solid-js';
 import { createComponent } from '@solidjs/web';
 
 // src/useQuery.ts
@@ -106,7 +106,7 @@ function useBaseQuery(options, Observer, queryClient) {
     }
     return defaultOptions;
   });
-  const observer = new Observer(client(), defaultedOptions());
+  const observer = untrack(() => new Observer(client(), defaultedOptions()));
   const trackedDefaultedOptions = createMemo(() => defaultedOptions());
   createRenderEffect(
     () => trackedDefaultedOptions(),
@@ -114,7 +114,9 @@ function useBaseQuery(options, Observer, queryClient) {
       observer.setOptions(opts);
     }
   );
-  let observerResult = observer.getOptimisticResult(defaultedOptions());
+  let observerResult = untrack(
+    () => observer.getOptimisticResult(defaultedOptions())
+  );
   const [state, setState] = createStore(
     _stripFnsForSSR(observerResult)
   );
@@ -264,17 +266,26 @@ function useInfiniteQuery(options, queryClient) {
 }
 function useMutation(options, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
-  const observer = new MutationObserver(client(), options());
-  createMemo(() => {
-    observer.setOptions(options());
-  });
+  const observer = untrack(
+    () => new MutationObserver(
+      client(),
+      options()
+    )
+  );
+  createRenderEffect(
+    () => options(),
+    (opts) => {
+      observer.setOptions(opts);
+    }
+  );
   const mutate = (variables, mutateOptions) => {
     observer.mutate(variables, mutateOptions).catch(noop);
   };
+  const initialResult = untrack(() => observer.getCurrentResult());
   const [state, setState] = createStore({
-    ...observer.getCurrentResult(),
+    ...initialResult,
     mutate,
-    mutateAsync: observer.getCurrentResult().mutate
+    mutateAsync: initialResult.mutate
   });
   const unsubscribe = observer.subscribe((result) => {
     setState(() => ({
@@ -309,16 +320,20 @@ function useQueries(queriesOptions, queryClient) {
       })
     )
   );
-  const observer = new QueriesObserver(
-    client(),
-    defaultedQueries(),
-    queriesOptions().combine ? {
-      combine: queriesOptions().combine
-    } : void 0
+  const observer = untrack(
+    () => new QueriesObserver(
+      client(),
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    )
   );
-  const [, getCombinedResult] = observer.getOptimisticResult(
-    defaultedQueries(),
-    queriesOptions().combine
+  const [, getCombinedResult] = untrack(
+    () => observer.getOptimisticResult(
+      defaultedQueries(),
+      queriesOptions().combine
+    )
   );
   const initialResult = getCombinedResult();
   const [state, setState] = createStore(
@@ -371,10 +386,15 @@ function queryOptions(options) {
 function useIsFetching(filters, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const queryCache = createMemo(() => client().getQueryCache());
-  const [fetches, setFetches] = createSignal(client().isFetching(filters?.()));
-  const unsubscribe = queryCache().subscribe(() => {
-    setFetches(client().isFetching(filters?.()));
-  });
+  const [fetches, setFetches] = createSignal(
+    untrack(() => client().isFetching(filters?.())),
+    { pureWrite: true }
+  );
+  const unsubscribe = untrack(
+    () => queryCache().subscribe(() => {
+      setFetches(client().isFetching(filters?.()));
+    })
+  );
   onCleanup(unsubscribe);
   return fetches;
 }
@@ -392,11 +412,14 @@ function useIsMutating(filters, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const mutationCache = createMemo(() => client().getMutationCache());
   const [mutations, setMutations] = createSignal(
-    client().isMutating(filters?.())
+    untrack(() => client().isMutating(filters?.())),
+    { pureWrite: true }
+  );
+  const unsubscribe = untrack(
+    () => mutationCache().subscribe((_result) => {
+      setMutations(client().isMutating(filters?.()));
+    })
   );
-  const unsubscribe = mutationCache().subscribe((_result) => {
-    setMutations(client().isMutating(filters?.()));
-  });
   onCleanup(unsubscribe);
   return mutations;
 }
@@ -409,17 +432,20 @@ function useMutationState(options = () => ({}), queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const mutationCache = createMemo(() => client().getMutationCache());
   const [result, setResult] = createSignal(
-    getResult(mutationCache(), options())
+    untrack(() => getResult(mutationCache(), options())),
+    { pureWrite: true }
+  );
+  const unsubscribe = untrack(
+    () => mutationCache().subscribe(() => {
+      setResult((prev) => {
+        const nextResult = replaceEqualDeep(
+          prev,
+          getResult(mutationCache(), options())
+        );
+        return prev === nextResult ? prev : nextResult;
+      });
+    })
   );
-  const unsubscribe = mutationCache().subscribe(() => {
-    setResult((prev) => {
-      const nextResult = replaceEqualDeep(
-        prev,
-        getResult(mutationCache(), options())
-      );
-      return prev === nextResult ? prev : nextResult;
-    });
-  });
   onCleanup(unsubscribe);
   return result;
 }

package/build/index.cjs

@@ -98,7 +98,7 @@ function useBaseQuery(options, Observer, queryClient) {
     }
     return defaultOptions;
   });
-  const observer = new Observer(client(), defaultedOptions());
+  const observer = solidJs.untrack(() => new Observer(client(), defaultedOptions()));
   const trackedDefaultedOptions = solidJs.createMemo(() => defaultedOptions());
   solidJs.createRenderEffect(
     () => trackedDefaultedOptions(),
@@ -106,7 +106,9 @@ function useBaseQuery(options, Observer, queryClient) {
       observer.setOptions(opts);
     }
   );
-  let observerResult = observer.getOptimisticResult(defaultedOptions());
+  let observerResult = solidJs.untrack(
+    () => observer.getOptimisticResult(defaultedOptions())
+  );
   const [state, setState] = solidJs.createStore(
     _stripFnsForSSR(observerResult)
   );
@@ -256,17 +258,26 @@ function useInfiniteQuery(options, queryClient) {
 }
 function useMutation(options, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
-  const observer = new queryCore.MutationObserver(client(), options());
-  solidJs.createMemo(() => {
-    observer.setOptions(options());
-  });
+  const observer = solidJs.untrack(
+    () => new queryCore.MutationObserver(
+      client(),
+      options()
+    )
+  );
+  solidJs.createRenderEffect(
+    () => options(),
+    (opts) => {
+      observer.setOptions(opts);
+    }
+  );
   const mutate = (variables, mutateOptions) => {
     observer.mutate(variables, mutateOptions).catch(queryCore.noop);
   };
+  const initialResult = solidJs.untrack(() => observer.getCurrentResult());
   const [state, setState] = solidJs.createStore({
-    ...observer.getCurrentResult(),
+    ...initialResult,
     mutate,
-    mutateAsync: observer.getCurrentResult().mutate
+    mutateAsync: initialResult.mutate
   });
   const unsubscribe = observer.subscribe((result) => {
     setState(() => ({
@@ -301,16 +312,20 @@ function useQueries(queriesOptions, queryClient) {
       })
     )
   );
-  const observer = new queryCore.QueriesObserver(
-    client(),
-    defaultedQueries(),
-    queriesOptions().combine ? {
-      combine: queriesOptions().combine
-    } : void 0
+  const observer = solidJs.untrack(
+    () => new queryCore.QueriesObserver(
+      client(),
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    )
   );
-  const [, getCombinedResult] = observer.getOptimisticResult(
-    defaultedQueries(),
-    queriesOptions().combine
+  const [, getCombinedResult] = solidJs.untrack(
+    () => observer.getOptimisticResult(
+      defaultedQueries(),
+      queriesOptions().combine
+    )
   );
   const initialResult = getCombinedResult();
   const [state, setState] = solidJs.createStore(
@@ -363,10 +378,15 @@ function queryOptions(options) {
 function useIsFetching(filters, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
   const queryCache = solidJs.createMemo(() => client().getQueryCache());
-  const [fetches, setFetches] = solidJs.createSignal(client().isFetching(filters?.()));
-  const unsubscribe = queryCache().subscribe(() => {
-    setFetches(client().isFetching(filters?.()));
-  });
+  const [fetches, setFetches] = solidJs.createSignal(
+    solidJs.untrack(() => client().isFetching(filters?.())),
+    { pureWrite: true }
+  );
+  const unsubscribe = solidJs.untrack(
+    () => queryCache().subscribe(() => {
+      setFetches(client().isFetching(filters?.()));
+    })
+  );
   solidJs.onCleanup(unsubscribe);
   return fetches;
 }
@@ -384,11 +404,14 @@ function useIsMutating(filters, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
   const mutationCache = solidJs.createMemo(() => client().getMutationCache());
   const [mutations, setMutations] = solidJs.createSignal(
-    client().isMutating(filters?.())
+    solidJs.untrack(() => client().isMutating(filters?.())),
+    { pureWrite: true }
+  );
+  const unsubscribe = solidJs.untrack(
+    () => mutationCache().subscribe((_result) => {
+      setMutations(client().isMutating(filters?.()));
+    })
   );
-  const unsubscribe = mutationCache().subscribe((_result) => {
-    setMutations(client().isMutating(filters?.()));
-  });
   solidJs.onCleanup(unsubscribe);
   return mutations;
 }
@@ -401,17 +424,20 @@ function useMutationState(options = () => ({}), queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
   const mutationCache = solidJs.createMemo(() => client().getMutationCache());
   const [result, setResult] = solidJs.createSignal(
-    getResult(mutationCache(), options())
+    solidJs.untrack(() => getResult(mutationCache(), options())),
+    { pureWrite: true }
+  );
+  const unsubscribe = solidJs.untrack(
+    () => mutationCache().subscribe(() => {
+      setResult((prev) => {
+        const nextResult = queryCore.replaceEqualDeep(
+          prev,
+          getResult(mutationCache(), options())
+        );
+        return prev === nextResult ? prev : nextResult;
+      });
+    })
   );
-  const unsubscribe = mutationCache().subscribe(() => {
-    setResult((prev) => {
-      const nextResult = queryCore.replaceEqualDeep(
-        prev,
-        getResult(mutationCache(), options())
-      );
-      return prev === nextResult ? prev : nextResult;
-    });
-  });
   solidJs.onCleanup(unsubscribe);
   return result;
 }

package/build/index.js

@@ -1,6 +1,6 @@
 import { MutationObserver, shouldThrowError, QueriesObserver, QueryClient as QueryClient$1, replaceEqualDeep, noop, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
-import { createContext, useContext, onCleanup, createMemo, createStore, createRenderEffect, merge, createEffect, reconcile, createSignal, isPending, refresh, snapshot } from 'solid-js';
+import { createContext, useContext, onCleanup, createMemo, untrack, createRenderEffect, createStore, merge, createEffect, reconcile, createSignal, isPending, refresh, snapshot } from 'solid-js';
 import { createComponent } from '@solidjs/web';
 
 // src/useQuery.ts
@@ -97,7 +97,7 @@ function useBaseQuery(options, Observer, queryClient) {
     }
     return defaultOptions;
   });
-  const observer = new Observer(client(), defaultedOptions());
+  const observer = untrack(() => new Observer(client(), defaultedOptions()));
   const trackedDefaultedOptions = createMemo(() => defaultedOptions());
   createRenderEffect(
     () => trackedDefaultedOptions(),
@@ -105,7 +105,9 @@ function useBaseQuery(options, Observer, queryClient) {
       observer.setOptions(opts);
     }
   );
-  let observerResult = observer.getOptimisticResult(defaultedOptions());
+  let observerResult = untrack(
+    () => observer.getOptimisticResult(defaultedOptions())
+  );
   const [state, setState] = createStore(
     _stripFnsForSSR(observerResult)
   );
@@ -255,17 +257,26 @@ function useInfiniteQuery(options, queryClient) {
 }
 function useMutation(options, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
-  const observer = new MutationObserver(client(), options());
-  createMemo(() => {
-    observer.setOptions(options());
-  });
+  const observer = untrack(
+    () => new MutationObserver(
+      client(),
+      options()
+    )
+  );
+  createRenderEffect(
+    () => options(),
+    (opts) => {
+      observer.setOptions(opts);
+    }
+  );
   const mutate = (variables, mutateOptions) => {
     observer.mutate(variables, mutateOptions).catch(noop);
   };
+  const initialResult = untrack(() => observer.getCurrentResult());
   const [state, setState] = createStore({
-    ...observer.getCurrentResult(),
+    ...initialResult,
     mutate,
-    mutateAsync: observer.getCurrentResult().mutate
+    mutateAsync: initialResult.mutate
   });
   const unsubscribe = observer.subscribe((result) => {
     setState(() => ({
@@ -300,16 +311,20 @@ function useQueries(queriesOptions, queryClient) {
       })
     )
   );
-  const observer = new QueriesObserver(
-    client(),
-    defaultedQueries(),
-    queriesOptions().combine ? {
-      combine: queriesOptions().combine
-    } : void 0
+  const observer = untrack(
+    () => new QueriesObserver(
+      client(),
+      defaultedQueries(),
+      queriesOptions().combine ? {
+        combine: queriesOptions().combine
+      } : void 0
+    )
   );
-  const [, getCombinedResult] = observer.getOptimisticResult(
-    defaultedQueries(),
-    queriesOptions().combine
+  const [, getCombinedResult] = untrack(
+    () => observer.getOptimisticResult(
+      defaultedQueries(),
+      queriesOptions().combine
+    )
   );
   const initialResult = getCombinedResult();
   const [state, setState] = createStore(
@@ -362,10 +377,15 @@ function queryOptions(options) {
 function useIsFetching(filters, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const queryCache = createMemo(() => client().getQueryCache());
-  const [fetches, setFetches] = createSignal(client().isFetching(filters?.()));
-  const unsubscribe = queryCache().subscribe(() => {
-    setFetches(client().isFetching(filters?.()));
-  });
+  const [fetches, setFetches] = createSignal(
+    untrack(() => client().isFetching(filters?.())),
+    { pureWrite: true }
+  );
+  const unsubscribe = untrack(
+    () => queryCache().subscribe(() => {
+      setFetches(client().isFetching(filters?.()));
+    })
+  );
   onCleanup(unsubscribe);
   return fetches;
 }
@@ -383,11 +403,14 @@ function useIsMutating(filters, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const mutationCache = createMemo(() => client().getMutationCache());
   const [mutations, setMutations] = createSignal(
-    client().isMutating(filters?.())
+    untrack(() => client().isMutating(filters?.())),
+    { pureWrite: true }
+  );
+  const unsubscribe = untrack(
+    () => mutationCache().subscribe((_result) => {
+      setMutations(client().isMutating(filters?.()));
+    })
   );
-  const unsubscribe = mutationCache().subscribe((_result) => {
-    setMutations(client().isMutating(filters?.()));
-  });
   onCleanup(unsubscribe);
   return mutations;
 }
@@ -400,17 +423,20 @@ function useMutationState(options = () => ({}), queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
   const mutationCache = createMemo(() => client().getMutationCache());
   const [result, setResult] = createSignal(
-    getResult(mutationCache(), options())
+    untrack(() => getResult(mutationCache(), options())),
+    { pureWrite: true }
+  );
+  const unsubscribe = untrack(
+    () => mutationCache().subscribe(() => {
+      setResult((prev) => {
+        const nextResult = replaceEqualDeep(
+          prev,
+          getResult(mutationCache(), options())
+        );
+        return prev === nextResult ? prev : nextResult;
+      });
+    })
   );
-  const unsubscribe = mutationCache().subscribe(() => {
-    setResult((prev) => {
-      const nextResult = replaceEqualDeep(
-        prev,
-        getResult(mutationCache(), options())
-      );
-      return prev === nextResult ? prev : nextResult;
-    });
-  });
   onCleanup(unsubscribe);
   return result;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tanstack/solid-query",
-  "version": "6.0.0-alpha.1",
+  "version": "6.0.0-beta.3",
   "description": "Primitives for managing, caching and syncing asynchronous and remote data in Solid",
   "author": "tannerlinsley",
   "license": "MIT",
@@ -55,9 +55,9 @@
     "@solidjs/web": "2.0.0-beta.4",
     "babel-preset-solid": "2.0.0-beta.4",
     "npm-run-all2": "^5.0.0",
-    "solid-js": "2.0.0-beta.4",
+    "solid-js": "2.0.0-beta.5",
     "tsup-preset-solid": "^2.2.0",
-    "vite-plugin-solid": "3.0.0-next.2",
+    "vite-plugin-solid": "3.0.0-next.4",
     "@tanstack/query-test-utils": "0.0.0"
   },
   "peerDependencies": {

package/src/useBaseQuery.ts

@@ -11,6 +11,7 @@ import {
   reconcile,
   refresh,
   snapshot,
+  untrack,
 } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
 import { useIsRestoring } from './isRestoring'
@@ -174,7 +175,7 @@ export function useBaseQuery<
     return defaultOptions
   })
 
-  const observer = new Observer(client(), defaultedOptions())
+  const observer = untrack(() => new Observer(client(), defaultedOptions()))
 
   // Track options reactively so the queryResource memo re-runs on change.
   const trackedDefaultedOptions = createMemo(() => defaultedOptions())
@@ -189,7 +190,10 @@ export function useBaseQuery<
     },
   )
 
-  let observerResult = observer.getOptimisticResult(defaultedOptions())
+  let observerResult = untrack(() =>
+    observer.getOptimisticResult(defaultedOptions()),
+  )
+
   const [state, setState] = createStore<QueryObserverResult<TData, TError>>(
     _stripFnsForSSR(observerResult),
   )

package/src/useIsFetching.ts

@@ -1,4 +1,4 @@
-import { createMemo, createSignal, onCleanup } from 'solid-js'
+import { createMemo, createSignal, onCleanup, untrack } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
 import type { QueryFilters } from '@tanstack/query-core'
 import type { QueryClient } from './QueryClient'
@@ -11,11 +11,16 @@ export function useIsFetching(
   const client = createMemo(() => useQueryClient(queryClient?.()))
   const queryCache = createMemo(() => client().getQueryCache())
 
-  const [fetches, setFetches] = createSignal(client().isFetching(filters?.()))
+  const [fetches, setFetches] = createSignal(
+    untrack(() => client().isFetching(filters?.())),
+    { pureWrite: true },
+  )
 
-  const unsubscribe = queryCache().subscribe(() => {
-    setFetches(client().isFetching(filters?.()))
-  })
+  const unsubscribe = untrack(() =>
+    queryCache().subscribe(() => {
+      setFetches(client().isFetching(filters?.()))
+    }),
+  )
 
   onCleanup(unsubscribe)
 

package/src/useIsMutating.ts

@@ -1,4 +1,4 @@
-import { createMemo, createSignal, onCleanup } from 'solid-js'
+import { createMemo, createSignal, onCleanup, untrack } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
 import type { MutationFilters } from '@tanstack/query-core'
 import type { QueryClient } from './QueryClient'
@@ -12,12 +12,15 @@ export function useIsMutating(
   const mutationCache = createMemo(() => client().getMutationCache())
 
   const [mutations, setMutations] = createSignal(
-    client().isMutating(filters?.()),
+    untrack(() => client().isMutating(filters?.())),
+    { pureWrite: true },
   )
 
-  const unsubscribe = mutationCache().subscribe((_result) => {
-    setMutations(client().isMutating(filters?.()))
-  })
+  const unsubscribe = untrack(() =>
+    mutationCache().subscribe((_result) => {
+      setMutations(client().isMutating(filters?.()))
+    }),
+  )
 
   onCleanup(unsubscribe)
 

package/src/useMutation.ts

@@ -4,6 +4,7 @@ import {
   createRenderEffect,
   createStore,
   onCleanup,
+  untrack,
 } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
 import type { DefaultError } from '@tanstack/query-core'
@@ -27,17 +28,21 @@ export function useMutation<
 ): UseMutationResult<TData, TError, TVariables, TOnMutateResult> {
   const client = createMemo(() => useQueryClient(queryClient?.()))
 
-  const observer = new MutationObserver<
-    TData,
-    TError,
-    TVariables,
-    TOnMutateResult
-  >(client(), options())
+  const observer = untrack(
+    () =>
+      new MutationObserver<TData, TError, TVariables, TOnMutateResult>(
+        client(),
+        options(),
+      ),
+  )
 
   // Track options changes and update observer
-  createMemo(() => {
-    observer.setOptions(options())
-  })
+  createRenderEffect(
+    () => options(),
+    (opts) => {
+      observer.setOptions(opts)
+    },
+  )
 
   const mutate: UseMutateFunction<
     TData,
@@ -48,12 +53,13 @@ export function useMutation<
     observer.mutate(variables, mutateOptions).catch(noop)
   }
 
+  const initialResult = untrack(() => observer.getCurrentResult())
   const [state, setState] = createStore<
     UseMutationResult<TData, TError, TVariables, TOnMutateResult>
   >({
-    ...observer.getCurrentResult(),
+    ...initialResult,
     mutate,
-    mutateAsync: observer.getCurrentResult().mutate,
+    mutateAsync: initialResult.mutate,
   })
 
   const unsubscribe = observer.subscribe((result) => {

package/src/useMutationState.ts

@@ -1,4 +1,4 @@
-import { createMemo, createSignal, onCleanup } from 'solid-js'
+import { createMemo, createSignal, onCleanup, untrack } from 'solid-js'
 import { replaceEqualDeep } from '@tanstack/query-core'
 import { useQueryClient } from './QueryClientProvider'
 import type {
@@ -35,18 +35,21 @@ export function useMutationState<TResult = MutationState>(
   const mutationCache = createMemo(() => client().getMutationCache())
 
   const [result, setResult] = createSignal(
-    getResult(mutationCache(), options()),
+    untrack(() => getResult(mutationCache(), options())),
+    { pureWrite: true },
   )
 
-  const unsubscribe = mutationCache().subscribe(() => {
-    setResult((prev) => {
-      const nextResult = replaceEqualDeep(
-        prev,
-        getResult(mutationCache(), options()),
-      )
-      return prev === nextResult ? prev : nextResult
-    })
-  })
+  const unsubscribe = untrack(() =>
+    mutationCache().subscribe(() => {
+      setResult((prev) => {
+        const nextResult = replaceEqualDeep(
+          prev,
+          getResult(mutationCache(), options()),
+        )
+        return prev === nextResult ? prev : nextResult
+      })
+    }),
+  )
 
   onCleanup(unsubscribe)
 

package/src/useQueries.ts

@@ -6,6 +6,7 @@ import {
   merge,
   onCleanup,
   reconcile,
+  untrack,
 } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
 import { useIsRestoring } from './isRestoring'
@@ -205,20 +206,25 @@ export function useQueries<
     ),
   )
 
-  const observer = new QueriesObserver<TCombinedResult>(
-    client(),
-    defaultedQueries(),
-    queriesOptions().combine
-      ? ({
-          combine: queriesOptions().combine,
-        } as QueriesObserverOptions<TCombinedResult>)
-      : undefined,
+  const observer = untrack(
+    () =>
+      new QueriesObserver<TCombinedResult>(
+        client(),
+        defaultedQueries(),
+        queriesOptions().combine
+          ? ({
+              combine: queriesOptions().combine,
+            } as QueriesObserverOptions<TCombinedResult>)
+          : undefined,
+      ),
   )
 
   // Get initial optimistic result
-  const [, getCombinedResult] = observer.getOptimisticResult(
-    defaultedQueries(),
-    (queriesOptions() as QueriesObserverOptions<TCombinedResult>).combine,
+  const [, getCombinedResult] = untrack(() =>
+    observer.getOptimisticResult(
+      defaultedQueries(),
+      (queriesOptions() as QueriesObserverOptions<TCombinedResult>).combine,
+    ),
   )
 
   const initialResult = getCombinedResult()