@tanstack/solid-query 5.0.0-alpha.2 → 5.0.0-alpha.20

package/src/createInfiniteQuery.ts

@@ -1,10 +1,10 @@
 import type {
   QueryObserver,
   QueryKey,
-  QueryClient,
   DefaultError,
   InfiniteData,
 } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
 import { InfiniteQueryObserver } from '@tanstack/query-core'
 import type {
   CreateInfiniteQueryOptions,
@@ -12,6 +12,7 @@ import type {
 } from './types'
 import { createBaseQuery } from './createBaseQuery'
 import { createMemo } from 'solid-js'
+import type { Accessor } from 'solid-js'
 
 export function createInfiniteQuery<
   TQueryFnData,
@@ -27,7 +28,7 @@ export function createInfiniteQuery<
     TQueryKey,
     TPageParam
   >,
-  queryClient?: () => QueryClient,
+  queryClient?: Accessor<QueryClient>,
 ): CreateInfiniteQueryResult<TData, TError> {
   return createBaseQuery(
     createMemo(() => options()),

package/src/createMutation.ts

@@ -1,4 +1,5 @@
-import type { QueryClient, DefaultError } from '@tanstack/query-core'
+import type { DefaultError } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
 import { MutationObserver } from '@tanstack/query-core'
 import { useQueryClient } from './QueryClientProvider'
 import type {
@@ -6,6 +7,7 @@ import type {
   CreateMutationOptions,
   CreateMutationResult,
 } from './types'
+import type { Accessor } from 'solid-js'
 import { createComputed, onCleanup, on } from 'solid-js'
 import { createStore } from 'solid-js/store'
 import { shouldThrowError } from './utils'
@@ -18,7 +20,7 @@ export function createMutation<
   TContext = unknown,
 >(
   options: CreateMutationOptions<TData, TError, TVariables, TContext>,
-  queryClient?: () => QueryClient,
+  queryClient?: Accessor<QueryClient>,
 ): CreateMutationResult<TData, TError, TVariables, TContext> {
   const client = useQueryClient(queryClient?.())
 

package/src/createQueries.ts

@@ -1,11 +1,12 @@
 import type {
   QueriesPlaceholderDataFunction,
-  QueryClient,
   QueryFunction,
   QueryKey,
   DefaultError,
 } from '@tanstack/query-core'
 import { notifyManager, QueriesObserver } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
+import type { Accessor } from 'solid-js'
 import { createComputed, onCleanup, onMount } from 'solid-js'
 import { createStore, unwrap } from 'solid-js/store'
 import { useQueryClient } from './QueryClientProvider'
@@ -148,20 +149,20 @@ export type QueriesResults<
     CreateQueryResult[]
 
 export function createQueries<T extends any[]>(
-  queriesOptions: () => {
+  queriesOptions: Accessor<{
     queries: readonly [...QueriesOptions<T>]
-    queryClient?: QueryClient
-  },
+  }>,
+  queryClient?: Accessor<QueryClient>,
 ): QueriesResults<T> {
-  const queryClient = useQueryClient(queriesOptions().queryClient)
+  const client = useQueryClient(queryClient?.())
 
   const defaultedQueries = queriesOptions().queries.map((options) => {
-    const defaultedOptions = queryClient.defaultQueryOptions(options)
+    const defaultedOptions = client.defaultQueryOptions(options)
     defaultedOptions._optimisticResults = 'optimistic'
     return defaultedOptions
   })
 
-  const observer = new QueriesObserver(queryClient, defaultedQueries)
+  const observer = new QueriesObserver(client, defaultedQueries)
 
   const [state, setState] = createStore(
     observer.getOptimisticResult(defaultedQueries),
@@ -181,7 +182,7 @@ export function createQueries<T extends any[]>(
 
   createComputed(() => {
     const updatedQueries = queriesOptions().queries.map((options) => {
-      const defaultedOptions = queryClient.defaultQueryOptions(options)
+      const defaultedOptions = client.defaultQueryOptions(options)
       defaultedOptions._optimisticResults = 'optimistic'
       return defaultedOptions
     })

package/src/createQuery.ts

@@ -1,5 +1,7 @@
-import type { QueryClient, QueryKey, DefaultError } from '@tanstack/query-core'
+import type { QueryKey, DefaultError } from '@tanstack/query-core'
 import { QueryObserver } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
+import type { Accessor } from 'solid-js'
 import { createMemo } from 'solid-js'
 import { createBaseQuery } from './createBaseQuery'
 import type {
@@ -58,7 +60,7 @@ export function createQuery<
   TQueryKey extends QueryKey = QueryKey,
 >(
   options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  queryClient?: () => QueryClient,
+  queryClient?: Accessor<QueryClient>,
 ) {
   return createBaseQuery(
     createMemo(() => options()),

package/src/index.ts

@@ -8,6 +8,13 @@ export * from '@tanstack/query-core'
 
 // Solid Query
 export * from './types'
+export { QueryClient } from './QueryClient'
+export type {
+  QueryObserverOptions,
+  DefaultOptions,
+  QueryClientConfig,
+  InfiniteQueryObserverOptions,
+} from './QueryClient'
 export { createQuery } from './createQuery'
 export {
   QueryClientContext,

package/src/types.ts

@@ -2,17 +2,19 @@
 
 import type {
   QueryKey,
-  QueryObserverOptions,
   QueryObserverResult,
   MutateFunction,
   MutationObserverOptions,
   MutationObserverResult,
   DefinedQueryObserverResult,
-  InfiniteQueryObserverOptions,
   InfiniteQueryObserverResult,
   WithRequired,
   DefaultError,
 } from '@tanstack/query-core'
+import type {
+  QueryObserverOptions,
+  InfiniteQueryObserverOptions,
+} from './QueryClient'
 
 export type FunctionedParams<T> = () => T
 

package/src/useIsFetching.ts

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

package/src/useIsMutating.ts

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