@tanstack/solid-query 5.71.7 → 5.71.8

package/src/{useQueries.ts → createQueries.ts}

@@ -14,14 +14,14 @@ import {
 import { useQueryClient } from './QueryClientProvider'
 import { useIsRestoring } from './isRestoring'
 import { noop } from './utils'
-import type { SolidQueryOptions, UseQueryResult } from './types'
+import type { CreateQueryResult, SolidQueryOptions } from './types'
 import type { Accessor } from 'solid-js'
+import type { QueryClient } from './QueryClient'
 import type {
   DefaultError,
   OmitKeyof,
   QueriesObserverOptions,
   QueriesPlaceholderDataFunction,
-  QueryClient,
   QueryFunction,
   QueryKey,
   QueryObserverOptions,
@@ -31,7 +31,7 @@ import type {
 
 // This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
 // `placeholderData` function does not have a parameter
-type UseQueryOptionsForUseQueries<
+type CreateQueryOptionsForCreateQueries<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
@@ -43,7 +43,7 @@ type UseQueryOptionsForUseQueries<
   placeholderData?: TQueryFnData | QueriesPlaceholderDataFunction<TQueryFnData>
   /**
    * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
-   * The `data` property on useQueries is a plain object and not a SolidJS Resource.
+   * The `data` property on createQueries is a plain object and not a SolidJS Resource.
    * It will not suspend when the data is loading.
    * Setting `suspense` to `true` will be a no-op.
    */
@@ -63,18 +63,18 @@ type GetOptions<T> =
     error?: infer TError
     data: infer TData
   }
-    ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>
+    ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData>
     : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
-      ? UseQueryOptionsForUseQueries<TQueryFnData, TError>
+      ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError>
       : T extends { data: infer TData; error?: infer TError }
-        ? UseQueryOptionsForUseQueries<unknown, TError, TData>
+        ? CreateQueryOptionsForCreateQueries<unknown, TError, TData>
         : // Part 2: responsible for applying explicit type parameter to function arguments, if tuple [TQueryFnData, TError, TData]
           T extends [infer TQueryFnData, infer TError, infer TData]
-          ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>
+          ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData>
           : T extends [infer TQueryFnData, infer TError]
-            ? UseQueryOptionsForUseQueries<TQueryFnData, TError>
+            ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError>
             : T extends [infer TQueryFnData]
-              ? UseQueryOptionsForUseQueries<TQueryFnData>
+              ? CreateQueryOptionsForCreateQueries<TQueryFnData>
               : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
                 T extends {
                     queryFn?:
@@ -83,30 +83,30 @@ type GetOptions<T> =
                     select?: (data: any) => infer TData
                     throwOnError?: ThrowOnError<any, infer TError, any, any>
                   }
-                ? UseQueryOptionsForUseQueries<
+                ? CreateQueryOptionsForCreateQueries<
                     TQueryFnData,
                     unknown extends TError ? DefaultError : TError,
                     unknown extends TData ? TQueryFnData : TData,
                     TQueryKey
                   >
                 : // Fallback
-                  UseQueryOptionsForUseQueries
+                  CreateQueryOptionsForCreateQueries
 
 type GetResults<T> =
   // Part 1: responsible for mapping explicit type parameter to function result, if object
   T extends { queryFnData: any; error?: infer TError; data: infer TData }
-    ? UseQueryResult<TData, TError>
+    ? CreateQueryResult<TData, TError>
     : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
-      ? UseQueryResult<TQueryFnData, TError>
+      ? CreateQueryResult<TQueryFnData, TError>
       : T extends { data: infer TData; error?: infer TError }
-        ? UseQueryResult<TData, TError>
+        ? CreateQueryResult<TData, TError>
         : // Part 2: responsible for mapping explicit type parameter to function result, if tuple
           T extends [any, infer TError, infer TData]
-          ? UseQueryResult<TData, TError>
+          ? CreateQueryResult<TData, TError>
           : T extends [infer TQueryFnData, infer TError]
-            ? UseQueryResult<TQueryFnData, TError>
+            ? CreateQueryResult<TQueryFnData, TError>
             : T extends [infer TQueryFnData]
-              ? UseQueryResult<TQueryFnData>
+              ? CreateQueryResult<TQueryFnData>
               : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
                 T extends {
                     queryFn?:
@@ -115,12 +115,12 @@ type GetResults<T> =
                     select?: (data: any) => infer TData
                     throwOnError?: ThrowOnError<any, infer TError, any, any>
                   }
-                ? UseQueryResult<
+                ? CreateQueryResult<
                     unknown extends TData ? TQueryFnData : TData,
                     unknown extends TError ? DefaultError : TError
                   >
                 : // Fallback
-                  UseQueryResult
+                  CreateQueryResult
 
 /**
  * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
@@ -130,7 +130,7 @@ type QueriesOptions<
   TResult extends Array<any> = [],
   TDepth extends ReadonlyArray<number> = [],
 > = TDepth['length'] extends MAXIMUM_DEPTH
-  ? Array<UseQueryOptionsForUseQueries>
+  ? Array<CreateQueryOptionsForCreateQueries>
   : T extends []
     ? []
     : T extends [infer Head]
@@ -146,7 +146,7 @@ type QueriesOptions<
           : // If T is *some* array but we couldn't assign unknown[] to it, then it must hold some known/homogenous type!
             // use this to infer the param types in the case of Array.map() argument
             T extends Array<
-                UseQueryOptionsForUseQueries<
+                CreateQueryOptionsForCreateQueries<
                   infer TQueryFnData,
                   infer TError,
                   infer TData,
@@ -154,7 +154,7 @@ type QueriesOptions<
                 >
               >
             ? Array<
-                UseQueryOptionsForUseQueries<
+                CreateQueryOptionsForCreateQueries<
                   TQueryFnData,
                   TError,
                   TData,
@@ -162,7 +162,7 @@ type QueriesOptions<
                 >
               >
             : // Fallback
-              Array<UseQueryOptionsForUseQueries>
+              Array<CreateQueryOptionsForCreateQueries>
 
 /**
  * QueriesResults reducer recursively maps type param to results
@@ -172,7 +172,7 @@ type QueriesResults<
   TResult extends Array<any> = [],
   TDepth extends ReadonlyArray<number> = [],
 > = TDepth['length'] extends MAXIMUM_DEPTH
-  ? Array<UseQueryResult>
+  ? Array<CreateQueryResult>
   : T extends []
     ? []
     : T extends [infer Head]
@@ -185,7 +185,7 @@ type QueriesResults<
           >
         : { [K in keyof T]: GetResults<T[K]> }
 
-export function useQueries<
+export function createQueries<
   T extends Array<any>,
   TCombinedResult extends QueriesResults<T> = QueriesResults<T>,
 >(

package/src/{useQuery.ts → createQuery.ts}

@@ -1,19 +1,20 @@
 import { QueryObserver } from '@tanstack/query-core'
 import { createMemo } from 'solid-js'
-import { useBaseQuery } from './useBaseQuery'
-import type { DefaultError, QueryClient, QueryKey } from '@tanstack/query-core'
+import { createBaseQuery } from './createBaseQuery'
+import type { DefaultError, QueryKey } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
 import type { Accessor } from 'solid-js'
 import type {
-  DefinedUseQueryResult,
-  UseQueryOptions,
-  UseQueryResult,
+  CreateQueryOptions,
+  CreateQueryResult,
+  DefinedCreateQueryResult,
 } from './types'
 import type {
   DefinedInitialDataOptions,
   UndefinedInitialDataOptions,
 } from './queryOptions'
 
-export function useQuery<
+export function createQuery<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
@@ -21,9 +22,9 @@ export function useQuery<
 >(
   options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
   queryClient?: () => QueryClient,
-): UseQueryResult<TData, TError>
+): CreateQueryResult<TData, TError>
 
-export function useQuery<
+export function createQuery<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
@@ -31,17 +32,17 @@ export function useQuery<
 >(
   options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
   queryClient?: () => QueryClient,
-): DefinedUseQueryResult<TData, TError>
-export function useQuery<
+): DefinedCreateQueryResult<TData, TError>
+export function createQuery<
   TQueryFnData,
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
 >(
-  options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+  options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
   queryClient?: Accessor<QueryClient>,
 ) {
-  return useBaseQuery(
+  return createBaseQuery(
     createMemo(() => options()),
     QueryObserver,
     queryClient,

package/src/index.ts

@@ -5,47 +5,14 @@ export * from '@tanstack/query-core'
 
 // Solid Query
 export * from './types'
-
-export type {
-  UseQueryOptions,
-  UseBaseQueryResult,
-  UseQueryResult,
-  DefinedUseBaseQueryResult,
-  DefinedUseQueryResult,
-  UseInfiniteQueryOptions,
-  UseInfiniteQueryResult,
-  DefinedUseInfiniteQueryResult,
-  UseMutationOptions,
-  UseMutateFunction,
-  UseMutateAsyncFunction,
-  UseBaseMutationResult,
-  UseMutationResult,
-  UseBaseQueryOptions,
-  SolidQueryOptions,
-  SolidInfiniteQueryOptions,
-  SolidMutationOptions,
-} from './types'
-
-// Compatibility types
+export { QueryClient } from './QueryClient'
 export type {
-  UseQueryOptions as CreateQueryOptions,
-  UseBaseQueryResult as CreateBaseQueryResult,
-  UseQueryResult as CreateQueryResult,
-  DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult,
-  DefinedUseQueryResult as DefinedCreateQueryResult,
-  UseInfiniteQueryOptions as CreateInfiniteQueryOptions,
-  UseInfiniteQueryResult as CreateInfiniteQueryResult,
-  DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult,
-  UseMutationOptions as CreateMutationOptions,
-  UseMutateFunction as CreateMutateFunction,
-  UseMutateAsyncFunction as CreateMutateAsyncFunction,
-  UseBaseMutationResult as CreateBaseMutationResult,
-  UseMutationResult as CreateMutationResult,
-  UseBaseQueryOptions as CreateBaseQueryOptions,
-} from './types'
-
-export { useQuery } from './useQuery'
-export { useQuery as createQuery } from './useQuery'
+  QueryObserverOptions,
+  DefaultOptions,
+  QueryClientConfig,
+  InfiniteQueryObserverOptions,
+} from './QueryClient'
+export { createQuery } from './createQuery'
 export { queryOptions } from './queryOptions'
 export type {
   DefinedInitialDataOptions,
@@ -58,17 +25,14 @@ export {
 } from './QueryClientProvider'
 export type { QueryClientProviderProps } from './QueryClientProvider'
 export { useIsFetching } from './useIsFetching'
-export { useInfiniteQuery } from './useInfiniteQuery'
-export { useInfiniteQuery as createInfiniteQuery } from './useInfiniteQuery'
+export { createInfiniteQuery } from './createInfiniteQuery'
 export { infiniteQueryOptions } from './infiniteQueryOptions'
 export type {
   DefinedInitialDataInfiniteOptions,
   UndefinedInitialDataInfiniteOptions,
 } from './infiniteQueryOptions'
-export { useMutation } from './useMutation'
-export { useMutation as createMutation } from './useMutation'
+export { createMutation } from './createMutation'
 export { useIsMutating } from './useIsMutating'
 export { useMutationState } from './useMutationState'
-export { useQueries } from './useQueries'
-export { useQueries as createQueries } from './useQueries'
+export { createQueries } from './createQueries'
 export { useIsRestoring, IsRestoringProvider } from './isRestoring'

package/src/types.ts

@@ -4,7 +4,6 @@ import type {
   DefaultError,
   DefinedInfiniteQueryObserverResult,
   DefinedQueryObserverResult,
-  InfiniteQueryObserverOptions,
   InfiniteQueryObserverResult,
   MutateFunction,
   MutationObserverOptions,
@@ -12,13 +11,15 @@ import type {
   OmitKeyof,
   Override,
   QueryKey,
-  QueryObserverOptions,
   QueryObserverResult,
 } from '@tanstack/query-core'
-
+import type {
+  InfiniteQueryObserverOptions,
+  QueryObserverOptions,
+} from './QueryClient'
 import type { Accessor } from 'solid-js'
 
-export interface UseBaseQueryOptions<
+export interface CreateBaseQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
@@ -37,7 +38,7 @@ export interface UseBaseQueryOptions<
   deferStream?: boolean
   /**
    * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
-   * The `data` property on useQuery is a SolidJS resource and will automatically suspend when the data is loading.
+   * The `data` property on createQuery is a SolidJS resource and will automatically suspend when the data is loading.
    * Setting `suspense` to `false` will be a no-op.
    */
   suspense?: boolean
@@ -48,7 +49,7 @@ export interface SolidQueryOptions<
   TError = DefaultError,
   TData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-> extends UseBaseQueryOptions<
+> extends CreateBaseQueryOptions<
     TQueryFnData,
     TError,
     TData,
@@ -56,7 +57,7 @@ export interface SolidQueryOptions<
     TQueryKey
   > {}
 
-export type UseQueryOptions<
+export type CreateQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
@@ -65,25 +66,25 @@ export type UseQueryOptions<
 
 /* --- Create Query and Create Base Query  Types --- */
 
-export type UseBaseQueryResult<
+export type CreateBaseQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = QueryObserverResult<TData, TError>
 
-export type UseQueryResult<
+export type CreateQueryResult<
   TData = unknown,
   TError = DefaultError,
-> = UseBaseQueryResult<TData, TError>
+> = CreateBaseQueryResult<TData, TError>
 
-export type DefinedUseBaseQueryResult<
+export type DefinedCreateBaseQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = DefinedQueryObserverResult<TData, TError>
 
-export type DefinedUseQueryResult<
+export type DefinedCreateQueryResult<
   TData = unknown,
   TError = DefaultError,
-> = DefinedUseBaseQueryResult<TData, TError>
+> = DefinedCreateBaseQueryResult<TData, TError>
 
 /* --- Create Infinite Queries Types --- */
 export interface SolidInfiniteQueryOptions<
@@ -114,13 +115,13 @@ export interface SolidInfiniteQueryOptions<
   deferStream?: boolean
   /**
    * @deprecated The `suspense` option has been deprecated in v5 and will be removed in the next major version.
-   * The `data` property on useInfiniteQuery is a SolidJS resource and will automatically suspend when the data is loading.
+   * The `data` property on createInfiniteQuery is a SolidJS resource and will automatically suspend when the data is loading.
    * Setting `suspense` to `false` will be a no-op.
    */
   suspense?: boolean
 }
 
-export type UseInfiniteQueryOptions<
+export type CreateInfiniteQueryOptions<
   TQueryFnData = unknown,
   TError = DefaultError,
   TData = TQueryFnData,
@@ -137,12 +138,12 @@ export type UseInfiniteQueryOptions<
   >
 >
 
-export type UseInfiniteQueryResult<
+export type CreateInfiniteQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = InfiniteQueryObserverResult<TData, TError>
 
-export type DefinedUseInfiniteQueryResult<
+export type DefinedCreateInfiniteQueryResult<
   TData = unknown,
   TError = DefaultError,
 > = DefinedInfiniteQueryObserverResult<TData, TError>
@@ -158,14 +159,14 @@ export interface SolidMutationOptions<
     '_defaulted'
   > {}
 
-export type UseMutationOptions<
+export type CreateMutationOptions<
   TData = unknown,
   TError = DefaultError,
   TVariables = void,
   TContext = unknown,
 > = Accessor<SolidMutationOptions<TData, TError, TVariables, TContext>>
 
-export type UseMutateFunction<
+export type CreateMutateFunction<
   TData = unknown,
   TError = DefaultError,
   TVariables = void,
@@ -174,28 +175,28 @@ export type UseMutateFunction<
   ...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>
 ) => void
 
-export type UseMutateAsyncFunction<
+export type CreateMutateAsyncFunction<
   TData = unknown,
   TError = DefaultError,
   TVariables = void,
   TContext = unknown,
 > = MutateFunction<TData, TError, TVariables, TContext>
 
-export type UseBaseMutationResult<
+export type CreateBaseMutationResult<
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
   TContext = unknown,
 > = Override<
   MutationObserverResult<TData, TError, TVariables, TContext>,
-  { mutate: UseMutateFunction<TData, TError, TVariables, TContext> }
+  { mutate: CreateMutateFunction<TData, TError, TVariables, TContext> }
 > & {
-  mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>
+  mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>
 }
 
-export type UseMutationResult<
+export type CreateMutationResult<
   TData = unknown,
   TError = DefaultError,
   TVariables = unknown,
   TContext = unknown,
-> = UseBaseMutationResult<TData, TError, TVariables, TContext>
+> = CreateBaseMutationResult<TData, TError, TVariables, TContext>

package/src/useIsFetching.ts

@@ -1,6 +1,7 @@
 import { createMemo, createSignal, onCleanup } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
-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'
 
 export function useIsFetching(

package/src/useIsMutating.ts

@@ -1,6 +1,7 @@
 import { createMemo, createSignal, onCleanup } from 'solid-js'
 import { useQueryClient } from './QueryClientProvider'
-import type { MutationFilters, QueryClient } from '@tanstack/query-core'
+import type { MutationFilters } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
 import type { Accessor } from 'solid-js'
 
 export function useIsMutating(

package/src/useMutationState.ts

@@ -6,9 +6,9 @@ import type {
   MutationCache,
   MutationFilters,
   MutationState,
-  QueryClient,
 } from '@tanstack/query-core'
 import type { Accessor } from 'solid-js'
+import type { QueryClient } from './QueryClient'
 
 type MutationStateOptions<TResult = MutationState> = {
   filters?: MutationFilters