@tanstack/solid-query - npm Package Compare versions

Comparing version 5.71.7 to 5.71.8

src/createBaseQuery.ts

+// Had to disable the lint rule because isServer type is defined as false
+// in solid-js/web package. I'll create a GitHub issue with them to see
+// why that happens.
+import { hydrate, notifyManager } from '@tanstack/query-core'
+import { isServer } from 'solid-js/web'
+import {
+  createComputed,
+  createMemo,
+  createResource,
+  createSignal,
+  on,
+  onCleanup,
+} from 'solid-js'
+import { createStore, reconcile, unwrap } from 'solid-js/store'
+import { useQueryClient } from './QueryClientProvider'
+import { shouldThrowError } from './utils'
+import { useIsRestoring } from './isRestoring'
+import type { CreateBaseQueryOptions } from './types'
+import type { Accessor, Signal } from 'solid-js'
+import type { QueryClient } from './QueryClient'
+import type {
+  Query,
+  QueryKey,
+  QueryObserver,
+  QueryObserverResult,
+} from '@tanstack/query-core'
+
+function reconcileFn<TData, TError>(
+  store: QueryObserverResult<TData, TError>,
+  result: QueryObserverResult<TData, TError>,
+  reconcileOption:
+    | string
+    | false
+    | ((oldData: TData | undefined, newData: TData) => TData),
+  queryHash?: string,
+): QueryObserverResult<TData, TError> {
+  if (reconcileOption === false) return result
+  if (typeof reconcileOption === 'function') {
+    const newData = reconcileOption(store.data, result.data as TData)
+    return { ...result, data: newData } as typeof result
+  }
+  let data = result.data
+  if (store.data === undefined) {
+    try {
+      data = structuredClone(data)
+    } catch (error) {
+      if (process.env.NODE_ENV !== 'production') {
+        if (error instanceof Error) {
+          console.warn(
+            `Unable to correctly reconcile data for query key: ${queryHash}. ` +
+              `Possibly because the query data contains data structures that aren't supported ` +
+              `by the 'structuredClone' algorithm. Consider using a callback function instead ` +
+              `to manage the reconciliation manually.\n\n Error Received: ${error.name} - ${error.message}`,
+          )
+        }
+      }
+    }
+  }
+  const newData = reconcile(data, { key: reconcileOption })(store.data)
+  return { ...result, data: newData } as typeof result
+}
+
+/**
+ * Solid's `onHydrated` functionality will silently "fail" (hydrate with an empty object)
+ * if the resource data is not serializable.
+ */
+const hydratableObserverResult = <
+  TQueryFnData,
+  TError,
+  TData,
+  TQueryKey extends QueryKey,
+  TDataHydratable,
+>(
+  query: Query<TQueryFnData, TError, TData, TQueryKey>,
+  result: QueryObserverResult<TDataHydratable, TError>,
+) => {
+  if (!isServer) return result
+  const obj: any = {
+    ...unwrap(result),
+    // During SSR, functions cannot be serialized, so we need to remove them
+    // This is safe because we will add these functions back when the query is hydrated
+    refetch: undefined,
+  }
+
+  // If the query is an infinite query, we need to remove additional properties
+  if ('fetchNextPage' in result) {
+    obj.fetchNextPage = undefined
+    obj.fetchPreviousPage = undefined
+  }
+
+  // We will also attach the dehydrated state of the query to the result
+  // This will be removed on client after hydration
+  obj.hydrationData = {
+    state: query.state,
+    queryKey: query.queryKey,
+    queryHash: query.queryHash,
+    ...(query.meta && { meta: query.meta }),
+  }
+
+  return obj
+}
+
+// Base Query Function that is used to create the query.
+export function createBaseQuery<
+  TQueryFnData,
+  TError,
+  TData,
+  TQueryData,
+  TQueryKey extends QueryKey,
+>(
+  options: Accessor<
+    CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
+  >,
+  Observer: typeof QueryObserver,
+  queryClient?: Accessor<QueryClient>,
+) {
+  type ResourceData = QueryObserverResult<TData, TError>
+
+  const client = createMemo(() => 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
+  // Causing a time out error. To prevent this we will queue the unsubscribe if the cleanup is called
+  // before the resource has loaded
+  let unsubscribeQueued = false
+
+  const defaultedOptions = createMemo(() => {
+    const defaultOptions = client().defaultQueryOptions(options())
+    defaultOptions._optimisticResults = isRestoring()
+      ? 'isRestoring'
+      : 'optimistic'
+    defaultOptions.structuralSharing = false
+    if (isServer) {
+      defaultOptions.retry = false
+      defaultOptions.throwOnError = true
+    }
+    return defaultOptions
+  })
+  const initialOptions = defaultedOptions()
+
+  const [observer, setObserver] = createSignal(
+    new Observer(client(), defaultedOptions()),
+  )
+
+  let observerResult = observer().getOptimisticResult(defaultedOptions())
+  const [state, setState] =
+    createStore<QueryObserverResult<TData, TError>>(observerResult)
+
+  const createServerSubscriber = (
+    resolve: (
+      data: ResourceData | PromiseLike<ResourceData | undefined> | undefined,
+    ) => void,
+    reject: (reason?: any) => void,
+  ) => {
+    return observer().subscribe((result) => {
+      notifyManager.batchCalls(() => {
+        const query = observer().getCurrentQuery()
+        const unwrappedResult = hydratableObserverResult(query, result)
+
+        if (unwrappedResult.isError) {
+          reject(unwrappedResult.error)
+          unsubscribeIfQueued()
+        } else {
+          resolve(unwrappedResult)
+          unsubscribeIfQueued()
+        }
+      })()
+    })
+  }
+
+  const unsubscribeIfQueued = () => {
+    if (unsubscribeQueued) {
+      unsubscribe?.()
+      unsubscribeQueued = false
+    }
+  }
+
+  const createClientSubscriber = () => {
+    const obs = observer()
+    return obs.subscribe((result) => {
+      observerResult = result
+      queueMicrotask(() => {
+        if (unsubscribe) {
+          refetch()
+        }
+      })
+    })
+  }
+
+  function setStateWithReconciliation(res: typeof observerResult) {
+    const opts = observer().options
+    // @ts-expect-error - Reconcile option is not correctly typed internally
+    const reconcileOptions = opts.reconcile
+
+    setState((store) => {
+      return reconcileFn(
+        store,
+        res,
+        reconcileOptions === undefined ? false : reconcileOptions,
+        opts.queryHash,
+      )
+    })
+  }
+
+  function createDeepSignal<T>(): Signal<T> {
+    return [
+      () => state,
+      (v: any) => {
+        const unwrapped = unwrap(state)
+        if (typeof v === 'function') {
+          v = v(unwrapped)
+        }
+        // Hydration data exists on first load after SSR,
+        // and should be removed from the observer result
+        if (v?.hydrationData) {
+          const { hydrationData, ...rest } = v
+          v = rest
+        }
+        setStateWithReconciliation(v)
+      },
+    ] as Signal<T>
+  }
+
+  /**
+   * Unsubscribe is set lazily, so that we can subscribe after hydration when needed.
+   */
+  let unsubscribe: (() => void) | null = null
+
+  /*
+    Fixes #7275
+    In a few cases, the observer could unmount before the resource is loaded.
+    This leads to Suspense boundaries to be suspended indefinitely.
+    This resolver will be called when the observer is unmounting 
+    but the resource is still in a loading state
+  */
+  let resolver: ((value: ResourceData) => void) | null = null
+  const [queryResource, { refetch }] = createResource<ResourceData | undefined>(
+    () => {
+      const obs = observer()
+      return new Promise((resolve, reject) => {
+        resolver = resolve
+        if (isServer) {
+          unsubscribe = createServerSubscriber(resolve, reject)
+        } else if (!unsubscribe && !isRestoring()) {
+          unsubscribe = createClientSubscriber()
+        }
+        obs.updateResult()
+
+        if (
+          observerResult.isError &&
+          !observerResult.isFetching &&
+          !isRestoring() &&
+          shouldThrowError(obs.options.throwOnError, [
+            observerResult.error,
+            obs.getCurrentQuery(),
+          ])
+        ) {
+          setStateWithReconciliation(observerResult)
+          return reject(observerResult.error)
+        }
+        if (!observerResult.isLoading) {
+          resolver = null
+          return resolve(
+            hydratableObserverResult(obs.getCurrentQuery(), observerResult),
+          )
+        }
+
+        setStateWithReconciliation(observerResult)
+      })
+    },
+    {
+      storage: createDeepSignal,
+
+      get deferStream() {
+        return options().deferStream
+      },
+
+      /**
+       * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
+       * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
+       *
+       * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
+       *
+       * Note that this is only invoked on the client, for queries that were originally run on the server.
+       */
+      onHydrated(_k, info) {
+        if (info.value && 'hydrationData' in info.value) {
+          hydrate(client(), {
+            // @ts-expect-error - hydrationData is not correctly typed internally
+            queries: [{ ...info.value.hydrationData }],
+          })
+        }
+
+        if (unsubscribe) return
+        /**
+         * Do not refetch query on mount if query was fetched on server,
+         * even if `staleTime` is not set.
+         */
+        const newOptions = { ...initialOptions }
+        if (
+          (initialOptions.staleTime || !initialOptions.initialData) &&
+          info.value
+        ) {
+          newOptions.refetchOnMount = false
+        }
+        // Setting the options as an immutable object to prevent
+        // wonky behavior with observer subscriptions
+        observer().setOptions(newOptions)
+        setStateWithReconciliation(observer().getOptimisticResult(newOptions))
+        unsubscribe = createClientSubscriber()
+      },
+    },
+  )
+
+  createComputed(
+    on(
+      client,
+      (c) => {
+        if (unsubscribe) {
+          unsubscribe()
+        }
+        const newObserver = new Observer(c, defaultedOptions())
+        unsubscribe = createClientSubscriber()
+        setObserver(newObserver)
+      },
+      {
+        defer: true,
+      },
+    ),
+  )
+
+  createComputed(
+    on(
+      isRestoring,
+      (restoring) => {
+        if (!restoring && !isServer) {
+          refetch()
+        }
+      },
+      { defer: true },
+    ),
+  )
+
+  onCleanup(() => {
+    if (isServer && queryResource.loading) {
+      unsubscribeQueued = true
+      return
+    }
+    if (unsubscribe) {
+      unsubscribe()
+      unsubscribe = null
+    }
+    if (resolver && !isServer) {
+      resolver(observerResult)
+      resolver = null
+    }
+  })
+
+  createComputed(
+    on(
+      [observer, defaultedOptions],
+      ([obs, opts]) => {
+        obs.setOptions(opts)
+        setStateWithReconciliation(obs.getOptimisticResult(opts))
+        refetch()
+      },
+      { defer: true },
+    ),
+  )
+
+  const handler = {
+    get(
+      target: QueryObserverResult<TData, TError>,
+      prop: keyof QueryObserverResult<TData, TError>,
+    ): any {
+      if (prop === 'data') {
+        if (state.data !== undefined) {
+          return queryResource.latest?.data
+        }
+        return queryResource()?.data
+      }
+      return Reflect.get(target, prop)
+    },
+  }
+
+  return new Proxy(state, handler)
+}

src/createInfiniteQuery.ts

+import { InfiniteQueryObserver } from '@tanstack/query-core'
+import { createMemo } from 'solid-js'
+import { createBaseQuery } from './createBaseQuery'
+import type {
+  DefaultError,
+  InfiniteData,
+  QueryKey,
+  QueryObserver,
+} from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
+import type {
+  CreateInfiniteQueryOptions,
+  CreateInfiniteQueryResult,
+  DefinedCreateInfiniteQueryResult,
+} from './types'
+import type { Accessor } from 'solid-js'
+import type {
+  DefinedInitialDataInfiniteOptions,
+  UndefinedInitialDataInfiniteOptions,
+} from './infiniteQueryOptions'
+
+export function createInfiniteQuery<
+  TQueryFnData,
+  TError = DefaultError,
+  TData = InfiniteData<TQueryFnData>,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+>(
+  options: DefinedInitialDataInfiniteOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  >,
+  queryClient?: Accessor<QueryClient>,
+): DefinedCreateInfiniteQueryResult<TData, TError>
+export function createInfiniteQuery<
+  TQueryFnData,
+  TError = DefaultError,
+  TData = InfiniteData<TQueryFnData>,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+>(
+  options: UndefinedInitialDataInfiniteOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  >,
+  queryClient?: Accessor<QueryClient>,
+): CreateInfiniteQueryResult<TData, TError>
+
+export function createInfiniteQuery<
+  TQueryFnData,
+  TError = DefaultError,
+  TData = InfiniteData<TQueryFnData>,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+>(
+  options: CreateInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryKey,
+    TPageParam
+  >,
+  queryClient?: Accessor<QueryClient>,
+): CreateInfiniteQueryResult<TData, TError> {
+  return createBaseQuery(
+    createMemo(() => options()),
+    InfiniteQueryObserver as typeof QueryObserver,
+    queryClient,
+  ) as CreateInfiniteQueryResult<TData, TError>
+}

src/createMutation.ts

+import { MutationObserver } from '@tanstack/query-core'
+import { createComputed, createMemo, on, onCleanup } from 'solid-js'
+import { createStore } from 'solid-js/store'
+import { useQueryClient } from './QueryClientProvider'
+import { noop, shouldThrowError } from './utils'
+import type { DefaultError } from '@tanstack/query-core'
+import type { QueryClient } from './QueryClient'
+import type {
+  CreateMutateFunction,
+  CreateMutationOptions,
+  CreateMutationResult,
+} from './types'
+import type { Accessor } from 'solid-js'
+
+// HOOK
+export function createMutation<
+  TData = unknown,
+  TError = DefaultError,
+  TVariables = void,
+  TContext = unknown,
+>(
+  options: CreateMutationOptions<TData, TError, TVariables, TContext>,
+  queryClient?: Accessor<QueryClient>,
+): CreateMutationResult<TData, TError, TVariables, TContext> {
+  const client = createMemo(() => useQueryClient(queryClient?.()))
+
+  const observer = new MutationObserver<TData, TError, TVariables, TContext>(
+    client(),
+    options(),
+  )
+
+  const mutate: CreateMutateFunction<TData, TError, TVariables, TContext> = (
+    variables,
+    mutateOptions,
+  ) => {
+    observer.mutate(variables, mutateOptions).catch(noop)
+  }
+
+  const [state, setState] = createStore<
+    CreateMutationResult<TData, TError, TVariables, TContext>
+  >({
+    ...observer.getCurrentResult(),
+    mutate,
+    mutateAsync: observer.getCurrentResult().mutate,
+  })
+
+  createComputed(() => {
+    observer.setOptions(options())
+  })
+
+  createComputed(
+    on(
+      () => state.status,
+      () => {
+        if (
+          state.isError &&
+          shouldThrowError(observer.options.throwOnError, [state.error])
+        ) {
+          throw state.error
+        }
+      },
+    ),
+  )
+
+  const unsubscribe = observer.subscribe((result) => {
+    setState({
+      ...result,
+      mutate,
+      mutateAsync: result.mutate,
+    })
+  })
+
+  onCleanup(unsubscribe)
+
+  return state
+}

src/createQueries.ts

+import { QueriesObserver } from '@tanstack/query-core'
+import { createStore, unwrap } from 'solid-js/store'
+import {
+  batch,
+  createComputed,
+  createMemo,
+  createRenderEffect,
+  createResource,
+  mergeProps,
+  on,
+  onCleanup,
+  onMount,
+} from 'solid-js'
+import { useQueryClient } from './QueryClientProvider'
+import { useIsRestoring } from './isRestoring'
+import { noop } from './utils'
+import type { CreateQueryResult, SolidQueryOptions } from './types'
+import type { Accessor } from 'solid-js'
+import type { QueryClient } from './QueryClient'
+import type {
+  DefaultError,
+  OmitKeyof,
+  QueriesObserverOptions,
+  QueriesPlaceholderDataFunction,
+  QueryFunction,
+  QueryKey,
+  QueryObserverOptions,
+  QueryObserverResult,
+  ThrowOnError,
+} from '@tanstack/query-core'
+
+// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
+// `placeholderData` function does not have a parameter
+type CreateQueryOptionsForCreateQueries<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = OmitKeyof<
+  SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+  'placeholderData' | 'suspense'
+> & {
+  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 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.
+   */
+  suspense?: boolean
+}
+
+// Avoid TS depth-limit error in case of large array literal
+type MAXIMUM_DEPTH = 20
+
+// Widen the type of the symbol to enable type inference even if skipToken is not immutable.
+type SkipTokenForUseQueries = symbol
+
+type GetOptions<T> =
+  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
+  T extends {
+    queryFnData: infer TQueryFnData
+    error?: infer TError
+    data: infer TData
+  }
+    ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData>
+    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
+      ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError>
+      : T extends { data: infer TData; error?: infer TError }
+        ? 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]
+          ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData>
+          : T extends [infer TQueryFnData, infer TError]
+            ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError>
+            : T extends [infer TQueryFnData]
+              ? CreateQueryOptionsForCreateQueries<TQueryFnData>
+              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
+                T extends {
+                    queryFn?:
+                      | QueryFunction<infer TQueryFnData, infer TQueryKey>
+                      | SkipTokenForUseQueries
+                    select?: (data: any) => infer TData
+                    throwOnError?: ThrowOnError<any, infer TError, any, any>
+                  }
+                ? CreateQueryOptionsForCreateQueries<
+                    TQueryFnData,
+                    unknown extends TError ? DefaultError : TError,
+                    unknown extends TData ? TQueryFnData : TData,
+                    TQueryKey
+                  >
+                : // Fallback
+                  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 }
+    ? CreateQueryResult<TData, TError>
+    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
+      ? CreateQueryResult<TQueryFnData, TError>
+      : T extends { data: infer TData; error?: infer TError }
+        ? CreateQueryResult<TData, TError>
+        : // Part 2: responsible for mapping explicit type parameter to function result, if tuple
+          T extends [any, infer TError, infer TData]
+          ? CreateQueryResult<TData, TError>
+          : T extends [infer TQueryFnData, infer TError]
+            ? CreateQueryResult<TQueryFnData, TError>
+            : T extends [infer TQueryFnData]
+              ? CreateQueryResult<TQueryFnData>
+              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
+                T extends {
+                    queryFn?:
+                      | QueryFunction<infer TQueryFnData, any>
+                      | SkipTokenForUseQueries
+                    select?: (data: any) => infer TData
+                    throwOnError?: ThrowOnError<any, infer TError, any, any>
+                  }
+                ? CreateQueryResult<
+                    unknown extends TData ? TQueryFnData : TData,
+                    unknown extends TError ? DefaultError : TError
+                  >
+                : // Fallback
+                  CreateQueryResult
+
+/**
+ * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
+ */
+type QueriesOptions<
+  T extends Array<any>,
+  TResult extends Array<any> = [],
+  TDepth extends ReadonlyArray<number> = [],
+> = TDepth['length'] extends MAXIMUM_DEPTH
+  ? Array<CreateQueryOptionsForCreateQueries>
+  : T extends []
+    ? []
+    : T extends [infer Head]
+      ? [...TResult, GetOptions<Head>]
+      : T extends [infer Head, ...infer Tail]
+        ? QueriesOptions<
+            [...Tail],
+            [...TResult, GetOptions<Head>],
+            [...TDepth, 1]
+          >
+        : ReadonlyArray<unknown> extends T
+          ? T
+          : // 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<
+                CreateQueryOptionsForCreateQueries<
+                  infer TQueryFnData,
+                  infer TError,
+                  infer TData,
+                  infer TQueryKey
+                >
+              >
+            ? Array<
+                CreateQueryOptionsForCreateQueries<
+                  TQueryFnData,
+                  TError,
+                  TData,
+                  TQueryKey
+                >
+              >
+            : // Fallback
+              Array<CreateQueryOptionsForCreateQueries>
+
+/**
+ * QueriesResults reducer recursively maps type param to results
+ */
+type QueriesResults<
+  T extends Array<any>,
+  TResult extends Array<any> = [],
+  TDepth extends ReadonlyArray<number> = [],
+> = TDepth['length'] extends MAXIMUM_DEPTH
+  ? Array<CreateQueryResult>
+  : T extends []
+    ? []
+    : T extends [infer Head]
+      ? [...TResult, GetResults<Head>]
+      : T extends [infer Head, ...infer Tail]
+        ? QueriesResults<
+            [...Tail],
+            [...TResult, GetResults<Head>],
+            [...TDepth, 1]
+          >
+        : { [K in keyof T]: GetResults<T[K]> }
+
+export function createQueries<
+  T extends Array<any>,
+  TCombinedResult extends QueriesResults<T> = QueriesResults<T>,
+>(
+  queriesOptions: Accessor<{
+    queries:
+      | readonly [...QueriesOptions<T>]
+      | readonly [...{ [K in keyof T]: GetOptions<T[K]> }]
+    combine?: (result: QueriesResults<T>) => TCombinedResult
+  }>,
+  queryClient?: Accessor<QueryClient>,
+): TCombinedResult {
+  const client = createMemo(() => useQueryClient(queryClient?.()))
+  const isRestoring = useIsRestoring()
+
+  const defaultedQueries = createMemo(() =>
+    queriesOptions().queries.map((options) =>
+      mergeProps(
+        client().defaultQueryOptions(options as QueryObserverOptions),
+        {
+          get _optimisticResults() {
+            return isRestoring() ? 'isRestoring' : 'optimistic'
+          },
+        },
+      ),
+    ),
+  )
+
+  const observer = new QueriesObserver(
+    client(),
+    defaultedQueries(),
+    queriesOptions().combine
+      ? ({
+          combine: queriesOptions().combine,
+        } as QueriesObserverOptions<TCombinedResult>)
+      : undefined,
+  )
+
+  const [state, setState] = createStore<TCombinedResult>(
+    observer.getOptimisticResult(
+      defaultedQueries(),
+      (queriesOptions() as QueriesObserverOptions<TCombinedResult>).combine,
+    )[1](),
+  )
+
+  createRenderEffect(
+    on(
+      () => queriesOptions().queries.length,
+      () =>
+        setState(
+          observer.getOptimisticResult(
+            defaultedQueries(),
+            (queriesOptions() as QueriesObserverOptions<TCombinedResult>)
+              .combine,
+          )[1](),
+        ),
+    ),
+  )
+
+  const dataResources = createMemo(
+    on(
+      () => state.length,
+      () =>
+        state.map((queryRes) => {
+          const dataPromise = () =>
+            new Promise((resolve) => {
+              if (queryRes.isFetching && queryRes.isLoading) return
+              resolve(unwrap(queryRes.data))
+            })
+          return createResource(dataPromise)
+        }),
+    ),
+  )
+
+  batch(() => {
+    const dataResources_ = dataResources()
+    for (let index = 0; index < dataResources_.length; index++) {
+      const dataResource = dataResources_[index]!
+      dataResource[1].mutate(() => unwrap(state[index]!.data))
+      dataResource[1].refetch()
+    }
+  })
+
+  let taskQueue: Array<() => void> = []
+  const subscribeToObserver = () =>
+    observer.subscribe((result) => {
+      taskQueue.push(() => {
+        batch(() => {
+          const dataResources_ = dataResources()
+          for (let index = 0; index < dataResources_.length; index++) {
+            const dataResource = dataResources_[index]!
+            const unwrappedResult = { ...unwrap(result[index]) }
+            // @ts-expect-error typescript pedantry regarding the possible range of index
+            setState(index, unwrap(unwrappedResult))
+            dataResource[1].mutate(() => unwrap(state[index]!.data))
+            dataResource[1].refetch()
+          }
+        })
+      })
+
+      queueMicrotask(() => {
+        const taskToRun = taskQueue.pop()
+        if (taskToRun) taskToRun()
+        taskQueue = []
+      })
+    })
+
+  let unsubscribe = noop
+  createComputed<() => void>((cleanup) => {
+    cleanup?.()
+    unsubscribe = isRestoring() ? noop : subscribeToObserver()
+    // cleanup needs to be scheduled after synchronous effects take place
+    return () => queueMicrotask(unsubscribe)
+  })
+  onCleanup(unsubscribe)
+
+  onMount(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine
+        ? ({
+            combine: queriesOptions().combine,
+          } as QueriesObserverOptions<TCombinedResult>)
+        : undefined,
+    )
+  })
+
+  createComputed(() => {
+    observer.setQueries(
+      defaultedQueries(),
+      queriesOptions().combine
+        ? ({
+            combine: queriesOptions().combine,
+          } as QueriesObserverOptions<TCombinedResult>)
+        : undefined,
+    )
+  })
+
+  const handler = (index: number) => ({
+    get(target: QueryObserverResult, prop: keyof QueryObserverResult): any {
+      if (prop === 'data') {
+        return dataResources()[index]![0]()
+      }
+      return Reflect.get(target, prop)
+    },
+  })
+
+  const getProxies = () =>
+    state.map((s, index) => {
+      return new Proxy(s, handler(index))
+    })
+
+  const [proxyState, setProxyState] = createStore(getProxies())
+  createRenderEffect(() => setProxyState(getProxies()))
+
+  return proxyState as TCombinedResult
+}

src/createQuery.ts

+import { QueryObserver } from '@tanstack/query-core'
+import { createMemo } from 'solid-js'
+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 {
+  CreateQueryOptions,
+  CreateQueryResult,
+  DefinedCreateQueryResult,
+} from './types'
+import type {
+  DefinedInitialDataOptions,
+  UndefinedInitialDataOptions,
+} from './queryOptions'
+
+export function createQuery<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: () => QueryClient,
+): CreateQueryResult<TData, TError>
+
+export function createQuery<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: () => QueryClient,
+): DefinedCreateQueryResult<TData, TError>
+export function createQuery<
+  TQueryFnData,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+>(
+  options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: Accessor<QueryClient>,
+) {
+  return createBaseQuery(
+    createMemo(() => options()),
+    QueryObserver,
+    queryClient,
+  )
+}

src/QueryClient.ts

+import { QueryClient as QueryCoreClient } from '@tanstack/query-core'
+import type {
+  DefaultOptions as CoreDefaultOptions,
+  DefaultError,
+  OmitKeyof,
+  QueryClientConfig as QueryCoreClientConfig,
+  InfiniteQueryObserverOptions as QueryCoreInfiniteQueryObserverOptions,
+  QueryObserverOptions as QueryCoreObserverOptions,
+  QueryKey,
+} from '@tanstack/query-core'
+
+export interface QueryObserverOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = never,
+> extends OmitKeyof<
+    QueryCoreObserverOptions<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryData,
+      TQueryKey,
+      TPageParam
+    >,
+    'structuralSharing'
+  > {
+  /**
+   * Set this to a reconciliation key to enable reconciliation between query results.
+   * Set this to `false` to disable reconciliation between query results.
+   * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+   * Defaults reconciliation to false.
+   */
+  reconcile?:
+    | string
+    | false
+    | ((oldData: TData | undefined, newData: TData) => TData)
+}
+
+export interface InfiniteQueryObserverOptions<
+  TQueryFnData = unknown,
+  TError = DefaultError,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+> extends OmitKeyof<
+    QueryCoreInfiniteQueryObserverOptions<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryData,
+      TQueryKey,
+      TPageParam
+    >,
+    'structuralSharing'
+  > {
+  /**
+   * Set this to a reconciliation key to enable reconciliation between query results.
+   * Set this to `false` to disable reconciliation between query results.
+   * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+   * Defaults reconciliation to false.
+   */
+  reconcile?:
+    | string
+    | false
+    | ((oldData: TData | undefined, newData: TData) => TData)
+}
+
+export interface DefaultOptions<TError = DefaultError>
+  extends CoreDefaultOptions<TError> {
+  queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>
+}
+
+export interface QueryClientConfig extends QueryCoreClientConfig {
+  defaultOptions?: DefaultOptions
+}
+
+export class QueryClient extends QueryCoreClient {
+  constructor(config: QueryClientConfig = {}) {
+    super(config)
+  }
+}

build/dev.cjs

@@ -9,2 +9,7 @@ 'use strict';
 // src/index.ts
+exports.QueryClient = class QueryClient extends queryCore.QueryClient {
+  constructor(config = {}) {
+    super(config);
+  }
+};
 exports.QueryClientContext = solidJs.createContext(void 0);
@@ -49,3 +54,3 @@ exports.useQueryClient = (queryClient) => {
 
-// src/useBaseQuery.ts
+// src/createBaseQuery.ts
 function reconcileFn(store$1, result, reconcileOption, queryHash) {
@@ -96,3 +101,3 @@ if (reconcileOption === false) return result;
 };
-function useBaseQuery(options, Observer, queryClient) {
+function createBaseQuery(options, Observer, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
@@ -303,5 +308,5 @@ const isRestoring = exports.useIsRestoring();
 
-// src/useQuery.ts
-function useQuery(options, queryClient) {
-  return useBaseQuery(
+// src/createQuery.ts
+function createQuery(options, queryClient) {
+  return createBaseQuery(
     solidJs.createMemo(() => options()),
@@ -327,4 +332,4 @@ queryCore.QueryObserver,
 }
-function useInfiniteQuery(options, queryClient) {
-  return useBaseQuery(
+function createInfiniteQuery(options, queryClient) {
+  return createBaseQuery(
     solidJs.createMemo(() => options()),
@@ -340,3 +345,3 @@ queryCore.InfiniteQueryObserver,
 }
-function useMutation(options, queryClient) {
+function createMutation(options, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
@@ -415,3 +420,3 @@ const observer = new queryCore.MutationObserver(
 }
-function useQueries(queriesOptions, queryClient) {
+function createQueries(queriesOptions, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
@@ -534,15 +539,11 @@ const isRestoring = exports.useIsRestoring();
 
-exports.createInfiniteQuery = useInfiniteQuery;
-exports.createMutation = useMutation;
-exports.createQueries = useQueries;
-exports.createQuery = useQuery;
+exports.createInfiniteQuery = createInfiniteQuery;
+exports.createMutation = createMutation;
+exports.createQueries = createQueries;
+exports.createQuery = createQuery;
 exports.infiniteQueryOptions = infiniteQueryOptions;
 exports.queryOptions = queryOptions;
-exports.useInfiniteQuery = useInfiniteQuery;
 exports.useIsFetching = useIsFetching;
 exports.useIsMutating = useIsMutating;
-exports.useMutation = useMutation;
 exports.useMutationState = useMutationState;
-exports.useQueries = useQueries;
-exports.useQuery = useQuery;
 Object.keys(queryCore).forEach(function (k) {
@@ -549,0 +550,0 @@ if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

build/dev.js

@@ -1,2 +0,2 @@
-import { MutationObserver, replaceEqualDeep, QueriesObserver, hydrate, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
+import { QueryClient as QueryClient$1, MutationObserver, replaceEqualDeep, QueriesObserver, hydrate, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
@@ -8,2 +8,7 @@ import { createContext, useContext, createRenderEffect, onCleanup, createMemo, createSignal, createComputed, on, createEffect, mergeProps, createResource, batch, onMount } from 'solid-js';
 // src/index.ts
+var QueryClient = class extends QueryClient$1 {
+  constructor(config = {}) {
+    super(config);
+  }
+};
 var QueryClientContext = createContext(void 0);
@@ -48,3 +53,3 @@ var useQueryClient = (queryClient) => {
 
-// src/useBaseQuery.ts
+// src/createBaseQuery.ts
 function reconcileFn(store, result, reconcileOption, queryHash) {
@@ -95,3 +100,3 @@ if (reconcileOption === false) return result;
 };
-function useBaseQuery(options, Observer, queryClient) {
+function createBaseQuery(options, Observer, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
@@ -302,5 +307,5 @@ const isRestoring = useIsRestoring();
 
-// src/useQuery.ts
-function useQuery(options, queryClient) {
-  return useBaseQuery(
+// src/createQuery.ts
+function createQuery(options, queryClient) {
+  return createBaseQuery(
     createMemo(() => options()),
@@ -326,4 +331,4 @@ QueryObserver,
 }
-function useInfiniteQuery(options, queryClient) {
-  return useBaseQuery(
+function createInfiniteQuery(options, queryClient) {
+  return createBaseQuery(
     createMemo(() => options()),
@@ -339,3 +344,3 @@ InfiniteQueryObserver,
 }
-function useMutation(options, queryClient) {
+function createMutation(options, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
@@ -414,3 +419,3 @@ const observer = new MutationObserver(
 }
-function useQueries(queriesOptions, queryClient) {
+function createQueries(queriesOptions, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
@@ -533,2 +538,2 @@ const isRestoring = useIsRestoring();
 
-export { IsRestoringProvider, QueryClientContext, QueryClientProvider, useInfiniteQuery as createInfiniteQuery, useMutation as createMutation, useQueries as createQueries, useQuery as createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };
+export { IsRestoringProvider, QueryClient, QueryClientContext, QueryClientProvider, createInfiniteQuery, createMutation, createQueries, createQuery, infiniteQueryOptions, queryOptions, useIsFetching, useIsMutating, useIsRestoring, useMutationState, useQueryClient };

build/index.cjs

@@ -9,2 +9,7 @@ 'use strict';
 // src/index.ts
+exports.QueryClient = class QueryClient extends queryCore.QueryClient {
+  constructor(config = {}) {
+    super(config);
+  }
+};
 exports.QueryClientContext = solidJs.createContext(void 0);
@@ -49,3 +54,3 @@ exports.useQueryClient = (queryClient) => {
 
-// src/useBaseQuery.ts
+// src/createBaseQuery.ts
 function reconcileFn(store$1, result, reconcileOption, queryHash) {
@@ -87,3 +92,3 @@ if (reconcileOption === false) return result;
 };
-function useBaseQuery(options, Observer, queryClient) {
+function createBaseQuery(options, Observer, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
@@ -294,5 +299,5 @@ const isRestoring = exports.useIsRestoring();
 
-// src/useQuery.ts
-function useQuery(options, queryClient) {
-  return useBaseQuery(
+// src/createQuery.ts
+function createQuery(options, queryClient) {
+  return createBaseQuery(
     solidJs.createMemo(() => options()),
@@ -318,4 +323,4 @@ queryCore.QueryObserver,
 }
-function useInfiniteQuery(options, queryClient) {
-  return useBaseQuery(
+function createInfiniteQuery(options, queryClient) {
+  return createBaseQuery(
     solidJs.createMemo(() => options()),
@@ -331,3 +336,3 @@ queryCore.InfiniteQueryObserver,
 }
-function useMutation(options, queryClient) {
+function createMutation(options, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
@@ -406,3 +411,3 @@ const observer = new queryCore.MutationObserver(
 }
-function useQueries(queriesOptions, queryClient) {
+function createQueries(queriesOptions, queryClient) {
   const client = solidJs.createMemo(() => exports.useQueryClient(queryClient?.()));
@@ -525,15 +530,11 @@ const isRestoring = exports.useIsRestoring();
 
-exports.createInfiniteQuery = useInfiniteQuery;
-exports.createMutation = useMutation;
-exports.createQueries = useQueries;
-exports.createQuery = useQuery;
+exports.createInfiniteQuery = createInfiniteQuery;
+exports.createMutation = createMutation;
+exports.createQueries = createQueries;
+exports.createQuery = createQuery;
 exports.infiniteQueryOptions = infiniteQueryOptions;
 exports.queryOptions = queryOptions;
-exports.useInfiniteQuery = useInfiniteQuery;
 exports.useIsFetching = useIsFetching;
 exports.useIsMutating = useIsMutating;
-exports.useMutation = useMutation;
 exports.useMutationState = useMutationState;
-exports.useQueries = useQueries;
-exports.useQuery = useQuery;
 Object.keys(queryCore).forEach(function (k) {
@@ -540,0 +541,0 @@ if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {

build/index.d.cts

@@ -1,2 +0,2 @@
-import { DefaultError, QueryKey, OmitKeyof, QueryObserverOptions, QueryObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, DefinedInfiniteQueryObserverResult, MutationObserverOptions, MutateFunction, Override, MutationObserverResult, DataTag, QueryClient, QueryFilters, InfiniteData, MutationFilters, MutationState, Mutation, QueryFunction, ThrowOnError, QueriesPlaceholderDataFunction } from '@tanstack/query-core';
+import { QueryClient as QueryClient$1, QueryClientConfig as QueryClientConfig$1, DefaultError, DefaultOptions as DefaultOptions$1, OmitKeyof, QueryKey, QueryObserverOptions as QueryObserverOptions$1, InfiniteQueryObserverOptions as InfiniteQueryObserverOptions$1, QueryObserverResult, DefinedQueryObserverResult, DefinedInfiniteQueryObserverResult, InfiniteQueryObserverResult, MutationObserverOptions, Override, MutationObserverResult, MutateFunction, DataTag, QueryFilters, InfiniteData, MutationFilters, MutationState, Mutation, QueryFunction, ThrowOnError, QueriesPlaceholderDataFunction } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
@@ -6,4 +6,32 @@ import * as solid_js from 'solid-js';
 
-interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
+interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends OmitKeyof<QueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
     /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface DefaultOptions<TError = DefaultError> extends DefaultOptions$1<TError> {
+    queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>;
+}
+interface QueryClientConfig extends QueryClientConfig$1 {
+    defaultOptions?: DefaultOptions;
+}
+declare class QueryClient extends QueryClient$1 {
+    constructor(config?: QueryClientConfig);
+}
+
+interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
+    /**
      * Only applicable while rendering queries on the server with streaming.
@@ -17,3 +45,3 @@ * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
      * @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.
@@ -23,9 +51,9 @@ */
 }
-interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
+interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
 }
-type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
-type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
-type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
-type DefinedUseBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
-type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedUseBaseQueryResult<TData, TError>;
+type CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
+type CreateBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
+type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQueryResult<TData, TError>;
+type DefinedCreateBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
+type DefinedCreateQueryResult<TData = unknown, TError = DefaultError> = DefinedCreateBaseQueryResult<TData, TError>;
 interface SolidInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'queryKey' | 'suspense'> {
@@ -42,3 +70,3 @@ queryKey: TQueryKey;
      * @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.
@@ -48,16 +76,16 @@ */
 }
-type UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>>;
-type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
-type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
+type CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>>;
+type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
+type DefinedCreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
 interface SolidMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted'> {
 }
-type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = Accessor<SolidMutationOptions<TData, TError, TVariables, TContext>>;
-type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
-type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
-type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
-    mutate: UseMutateFunction<TData, TError, TVariables, TContext>;
+type CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = Accessor<SolidMutationOptions<TData, TError, TVariables, TContext>>;
+type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
+type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
+type CreateBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
+    mutate: CreateMutateFunction<TData, TError, TVariables, TContext>;
 }> & {
-    mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+    mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>;
 };
-type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = UseBaseMutationResult<TData, TError, TVariables, TContext>;
+type CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = CreateBaseMutationResult<TData, TError, TVariables, TContext>;
 
@@ -77,4 +105,4 @@ type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
 
-declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): UseQueryResult<TData, TError>;
-declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedUseQueryResult<TData, TError>;
+declare function createQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): CreateQueryResult<TData, TError>;
+declare function createQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedCreateQueryResult<TData, TError>;
 
@@ -105,6 +133,6 @@ declare const QueryClientContext: solid_js.Context<(() => QueryClient) | undefined>;
 
-declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): DefinedUseInfiniteQueryResult<TData, TError>;
-declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): UseInfiniteQueryResult<TData, TError>;
+declare function createInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): DefinedCreateInfiniteQueryResult<TData, TError>;
+declare function createInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): CreateInfiniteQueryResult<TData, TError>;
 
-declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: UseMutationOptions<TData, TError, TVariables, TContext>, queryClient?: Accessor<QueryClient>): UseMutationResult<TData, TError, TVariables, TContext>;
+declare function createMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: CreateMutationOptions<TData, TError, TVariables, TContext>, queryClient?: Accessor<QueryClient>): CreateMutationResult<TData, TError, TVariables, TContext>;
 
@@ -119,7 +147,7 @@ declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
 
-type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
+type CreateQueryOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
     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.
@@ -136,13 +164,13 @@ * Setting `suspense` to `true` will be a no-op.
     data: infer TData;
-} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
     queryFnData: infer TQueryFnData;
     error?: infer TError;
-} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends {
     data: infer TData;
     error?: infer TError;
-} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
+} ? CreateQueryOptionsForCreateQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryOptionsForCreateQueries<TQueryFnData> : T extends {
     queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
     select?: (data: any) => infer TData;
     throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : CreateQueryOptionsForCreateQueries;
 type GetResults<T> = T extends {
@@ -152,17 +180,17 @@ queryFnData: any;
     data: infer TData;
-} ? UseQueryResult<TData, TError> : T extends {
+} ? CreateQueryResult<TData, TError> : T extends {
     queryFnData: infer TQueryFnData;
     error?: infer TError;
-} ? UseQueryResult<TQueryFnData, TError> : T extends {
+} ? CreateQueryResult<TQueryFnData, TError> : T extends {
     data: infer TData;
     error?: infer TError;
-} ? UseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryResult<TQueryFnData> : T extends {
+} ? CreateQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? CreateQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? CreateQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryResult<TQueryFnData> : T extends {
     queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
     select?: (data: any) => infer TData;
     throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
+} ? CreateQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : CreateQueryResult;
 /**
  * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
  */
-type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
+type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<CreateQueryOptionsForCreateQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
     ...Tail
@@ -175,7 +203,7 @@ ], [
     1
-]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
+]> : ReadonlyArray<unknown> extends T ? T : T extends Array<CreateQueryOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<CreateQueryOptionsForCreateQueries>;
 /**
  * QueriesResults reducer recursively maps type param to results
  */
-type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
+type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<CreateQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
     ...Tail
@@ -191,3 +219,3 @@ ], [
 };
-declare function useQueries<T extends Array<any>, TCombinedResult extends QueriesResults<T> = QueriesResults<T>>(queriesOptions: Accessor<{
+declare function createQueries<T extends Array<any>, TCombinedResult extends QueriesResults<T> = QueriesResults<T>>(queriesOptions: Accessor<{
     queries: readonly [...QueriesOptions<T>] | readonly [...{
@@ -202,2 +230,2 @@ [K in keyof T]: GetOptions<T[K]>;
 
-export { type UseBaseMutationResult as CreateBaseMutationResult, type UseBaseQueryOptions as CreateBaseQueryOptions, type UseBaseQueryResult as CreateBaseQueryResult, type UseInfiniteQueryOptions as CreateInfiniteQueryOptions, type UseInfiniteQueryResult as CreateInfiniteQueryResult, type UseMutateAsyncFunction as CreateMutateAsyncFunction, type UseMutateFunction as CreateMutateFunction, type UseMutationOptions as CreateMutationOptions, type UseMutationResult as CreateMutationResult, type UseQueryOptions as CreateQueryOptions, type UseQueryResult as CreateQueryResult, type DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult, type DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult, type DefinedUseQueryResult as DefinedCreateQueryResult, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DefinedUseBaseQueryResult, type DefinedUseInfiniteQueryResult, type DefinedUseQueryResult, IsRestoringProvider, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type SolidInfiniteQueryOptions, type SolidMutationOptions, type SolidQueryOptions, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, type UseBaseMutationResult, type UseBaseQueryOptions, type UseBaseQueryResult, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutateAsyncFunction, type UseMutateFunction, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, useInfiniteQuery as createInfiniteQuery, useMutation as createMutation, useQueries as createQueries, useQuery as createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };
+export { type CreateBaseMutationResult, type CreateBaseQueryOptions, type CreateBaseQueryResult, type CreateInfiniteQueryOptions, type CreateInfiniteQueryResult, type CreateMutateAsyncFunction, type CreateMutateFunction, type CreateMutationOptions, type CreateMutationResult, type CreateQueryOptions, type CreateQueryResult, type DefaultOptions, type DefinedCreateBaseQueryResult, type DefinedCreateInfiniteQueryResult, type DefinedCreateQueryResult, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type InfiniteQueryObserverOptions, IsRestoringProvider, QueryClient, type QueryClientConfig, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type QueryObserverOptions, type SolidInfiniteQueryOptions, type SolidMutationOptions, type SolidQueryOptions, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, createInfiniteQuery, createMutation, createQueries, createQuery, infiniteQueryOptions, queryOptions, useIsFetching, useIsMutating, useIsRestoring, useMutationState, useQueryClient };

build/index.d.ts

@@ -1,2 +0,2 @@
-import { DefaultError, QueryKey, OmitKeyof, QueryObserverOptions, QueryObserverResult, DefinedQueryObserverResult, InfiniteQueryObserverOptions, InfiniteQueryObserverResult, DefinedInfiniteQueryObserverResult, MutationObserverOptions, MutateFunction, Override, MutationObserverResult, DataTag, QueryClient, QueryFilters, InfiniteData, MutationFilters, MutationState, Mutation, QueryFunction, ThrowOnError, QueriesPlaceholderDataFunction } from '@tanstack/query-core';
+import { QueryClient as QueryClient$1, QueryClientConfig as QueryClientConfig$1, DefaultError, DefaultOptions as DefaultOptions$1, OmitKeyof, QueryKey, QueryObserverOptions as QueryObserverOptions$1, InfiniteQueryObserverOptions as InfiniteQueryObserverOptions$1, QueryObserverResult, DefinedQueryObserverResult, DefinedInfiniteQueryObserverResult, InfiniteQueryObserverResult, MutationObserverOptions, Override, MutationObserverResult, MutateFunction, DataTag, QueryFilters, InfiniteData, MutationFilters, MutationState, Mutation, QueryFunction, ThrowOnError, QueriesPlaceholderDataFunction } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
@@ -6,4 +6,32 @@ import * as solid_js from 'solid-js';
 
-interface UseBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
+interface QueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = never> extends OmitKeyof<QueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
     /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface InfiniteQueryObserverOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions$1<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'structuralSharing'> {
+    /**
+     * Set this to a reconciliation key to enable reconciliation between query results.
+     * Set this to `false` to disable reconciliation between query results.
+     * Set this to a function which accepts the old and new data and returns resolved data of the same type to implement custom reconciliation logic.
+     * Defaults reconciliation to false.
+     */
+    reconcile?: string | false | ((oldData: TData | undefined, newData: TData) => TData);
+}
+interface DefaultOptions<TError = DefaultError> extends DefaultOptions$1<TError> {
+    queries?: OmitKeyof<QueryObserverOptions<unknown, TError>, 'queryKey'>;
+}
+interface QueryClientConfig extends QueryClientConfig$1 {
+    defaultOptions?: DefaultOptions;
+}
+declare class QueryClient extends QueryClient$1 {
+    constructor(config?: QueryClientConfig);
+}
+
+interface CreateBaseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends OmitKeyof<QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>, 'suspense'> {
+    /**
      * Only applicable while rendering queries on the server with streaming.
@@ -17,3 +45,3 @@ * Set `deferStream` to `true` to wait for the query to resolve on the server before flushing the stream.
      * @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.
@@ -23,9 +51,9 @@ */
 }
-interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
+interface SolidQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> extends CreateBaseQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey> {
 }
-type UseQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
-type UseBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
-type UseQueryResult<TData = unknown, TError = DefaultError> = UseBaseQueryResult<TData, TError>;
-type DefinedUseBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
-type DefinedUseQueryResult<TData = unknown, TError = DefaultError> = DefinedUseBaseQueryResult<TData, TError>;
+type CreateQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>;
+type CreateBaseQueryResult<TData = unknown, TError = DefaultError> = QueryObserverResult<TData, TError>;
+type CreateQueryResult<TData = unknown, TError = DefaultError> = CreateBaseQueryResult<TData, TError>;
+type DefinedCreateBaseQueryResult<TData = unknown, TError = DefaultError> = DefinedQueryObserverResult<TData, TError>;
+type DefinedCreateQueryResult<TData = unknown, TError = DefaultError> = DefinedCreateBaseQueryResult<TData, TError>;
 interface SolidInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> extends OmitKeyof<InfiniteQueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey, TPageParam>, 'queryKey' | 'suspense'> {
@@ -42,3 +70,3 @@ queryKey: TQueryKey;
      * @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.
@@ -48,16 +76,16 @@ */
 }
-type UseInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>>;
-type UseInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
-type DefinedUseInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
+type CreateInfiniteQueryOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown> = Accessor<SolidInfiniteQueryOptions<TQueryFnData, TError, TData, TQueryFnData, TQueryKey, TPageParam>>;
+type CreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = InfiniteQueryObserverResult<TData, TError>;
+type DefinedCreateInfiniteQueryResult<TData = unknown, TError = DefaultError> = DefinedInfiniteQueryObserverResult<TData, TError>;
 interface SolidMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> extends OmitKeyof<MutationObserverOptions<TData, TError, TVariables, TContext>, '_defaulted'> {
 }
-type UseMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = Accessor<SolidMutationOptions<TData, TError, TVariables, TContext>>;
-type UseMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
-type UseMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
-type UseBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
-    mutate: UseMutateFunction<TData, TError, TVariables, TContext>;
+type CreateMutationOptions<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = Accessor<SolidMutationOptions<TData, TError, TVariables, TContext>>;
+type CreateMutateFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = (...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>) => void;
+type CreateMutateAsyncFunction<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown> = MutateFunction<TData, TError, TVariables, TContext>;
+type CreateBaseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = Override<MutationObserverResult<TData, TError, TVariables, TContext>, {
+    mutate: CreateMutateFunction<TData, TError, TVariables, TContext>;
 }> & {
-    mutateAsync: UseMutateAsyncFunction<TData, TError, TVariables, TContext>;
+    mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>;
 };
-type UseMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = UseBaseMutationResult<TData, TError, TVariables, TContext>;
+type CreateMutationResult<TData = unknown, TError = DefaultError, TVariables = unknown, TContext = unknown> = CreateBaseMutationResult<TData, TError, TVariables, TContext>;
 
@@ -77,4 +105,4 @@ type UndefinedInitialDataOptions<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = Accessor<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
 
-declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): UseQueryResult<TData, TError>;
-declare function useQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedUseQueryResult<TData, TError>;
+declare function createQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): CreateQueryResult<TData, TError>;
+declare function createQuery<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey>(options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>, queryClient?: () => QueryClient): DefinedCreateQueryResult<TData, TError>;
 
@@ -105,6 +133,6 @@ declare const QueryClientContext: solid_js.Context<(() => QueryClient) | undefined>;
 
-declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): DefinedUseInfiniteQueryResult<TData, TError>;
-declare function useInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): UseInfiniteQueryResult<TData, TError>;
+declare function createInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: DefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): DefinedCreateInfiniteQueryResult<TData, TError>;
+declare function createInfiniteQuery<TQueryFnData, TError = DefaultError, TData = InfiniteData<TQueryFnData>, TQueryKey extends QueryKey = QueryKey, TPageParam = unknown>(options: UndefinedInitialDataInfiniteOptions<TQueryFnData, TError, TData, TQueryKey, TPageParam>, queryClient?: Accessor<QueryClient>): CreateInfiniteQueryResult<TData, TError>;
 
-declare function useMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: UseMutationOptions<TData, TError, TVariables, TContext>, queryClient?: Accessor<QueryClient>): UseMutationResult<TData, TError, TVariables, TContext>;
+declare function createMutation<TData = unknown, TError = DefaultError, TVariables = void, TContext = unknown>(options: CreateMutationOptions<TData, TError, TVariables, TContext>, queryClient?: Accessor<QueryClient>): CreateMutationResult<TData, TError, TVariables, TContext>;
 
@@ -119,7 +147,7 @@ declare function useIsMutating(filters?: Accessor<MutationFilters>, queryClient?: Accessor<QueryClient>): Accessor<number>;
 
-type UseQueryOptionsForUseQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
+type CreateQueryOptionsForCreateQueries<TQueryFnData = unknown, TError = DefaultError, TData = TQueryFnData, TQueryKey extends QueryKey = QueryKey> = OmitKeyof<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>, 'placeholderData' | 'suspense'> & {
     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.
@@ -136,13 +164,13 @@ * Setting `suspense` to `true` will be a no-op.
     data: infer TData;
-} ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends {
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends {
     queryFnData: infer TQueryFnData;
     error?: infer TError;
-} ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends {
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends {
     data: infer TData;
     error?: infer TError;
-} ? UseQueryOptionsForUseQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? UseQueryOptionsForUseQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryOptionsForUseQueries<TQueryFnData> : T extends {
+} ? CreateQueryOptionsForCreateQueries<unknown, TError, TData> : T extends [infer TQueryFnData, infer TError, infer TData] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData> : T extends [infer TQueryFnData, infer TError] ? CreateQueryOptionsForCreateQueries<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryOptionsForCreateQueries<TQueryFnData> : T extends {
     queryFn?: QueryFunction<infer TQueryFnData, infer TQueryKey> | SkipTokenForUseQueries;
     select?: (data: any) => infer TData;
     throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? UseQueryOptionsForUseQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : UseQueryOptionsForUseQueries;
+} ? CreateQueryOptionsForCreateQueries<TQueryFnData, unknown extends TError ? DefaultError : TError, unknown extends TData ? TQueryFnData : TData, TQueryKey> : CreateQueryOptionsForCreateQueries;
 type GetResults<T> = T extends {
@@ -152,17 +180,17 @@ queryFnData: any;
     data: infer TData;
-} ? UseQueryResult<TData, TError> : T extends {
+} ? CreateQueryResult<TData, TError> : T extends {
     queryFnData: infer TQueryFnData;
     error?: infer TError;
-} ? UseQueryResult<TQueryFnData, TError> : T extends {
+} ? CreateQueryResult<TQueryFnData, TError> : T extends {
     data: infer TData;
     error?: infer TError;
-} ? UseQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? UseQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? UseQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? UseQueryResult<TQueryFnData> : T extends {
+} ? CreateQueryResult<TData, TError> : T extends [any, infer TError, infer TData] ? CreateQueryResult<TData, TError> : T extends [infer TQueryFnData, infer TError] ? CreateQueryResult<TQueryFnData, TError> : T extends [infer TQueryFnData] ? CreateQueryResult<TQueryFnData> : T extends {
     queryFn?: QueryFunction<infer TQueryFnData, any> | SkipTokenForUseQueries;
     select?: (data: any) => infer TData;
     throwOnError?: ThrowOnError<any, infer TError, any, any>;
-} ? UseQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : UseQueryResult;
+} ? CreateQueryResult<unknown extends TData ? TQueryFnData : TData, unknown extends TError ? DefaultError : TError> : CreateQueryResult;
 /**
  * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
  */
-type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryOptionsForUseQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
+type QueriesOptions<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<CreateQueryOptionsForCreateQueries> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetOptions<Head>] : T extends [infer Head, ...infer Tail] ? QueriesOptions<[
     ...Tail
@@ -175,7 +203,7 @@ ], [
     1
-]> : ReadonlyArray<unknown> extends T ? T : T extends Array<UseQueryOptionsForUseQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<UseQueryOptionsForUseQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<UseQueryOptionsForUseQueries>;
+]> : ReadonlyArray<unknown> extends T ? T : T extends Array<CreateQueryOptionsForCreateQueries<infer TQueryFnData, infer TError, infer TData, infer TQueryKey>> ? Array<CreateQueryOptionsForCreateQueries<TQueryFnData, TError, TData, TQueryKey>> : Array<CreateQueryOptionsForCreateQueries>;
 /**
  * QueriesResults reducer recursively maps type param to results
  */
-type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<UseQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
+type QueriesResults<T extends Array<any>, TResult extends Array<any> = [], TDepth extends ReadonlyArray<number> = []> = TDepth['length'] extends MAXIMUM_DEPTH ? Array<CreateQueryResult> : T extends [] ? [] : T extends [infer Head] ? [...TResult, GetResults<Head>] : T extends [infer Head, ...infer Tail] ? QueriesResults<[
     ...Tail
@@ -191,3 +219,3 @@ ], [
 };
-declare function useQueries<T extends Array<any>, TCombinedResult extends QueriesResults<T> = QueriesResults<T>>(queriesOptions: Accessor<{
+declare function createQueries<T extends Array<any>, TCombinedResult extends QueriesResults<T> = QueriesResults<T>>(queriesOptions: Accessor<{
     queries: readonly [...QueriesOptions<T>] | readonly [...{
@@ -202,2 +230,2 @@ [K in keyof T]: GetOptions<T[K]>;
 
-export { type UseBaseMutationResult as CreateBaseMutationResult, type UseBaseQueryOptions as CreateBaseQueryOptions, type UseBaseQueryResult as CreateBaseQueryResult, type UseInfiniteQueryOptions as CreateInfiniteQueryOptions, type UseInfiniteQueryResult as CreateInfiniteQueryResult, type UseMutateAsyncFunction as CreateMutateAsyncFunction, type UseMutateFunction as CreateMutateFunction, type UseMutationOptions as CreateMutationOptions, type UseMutationResult as CreateMutationResult, type UseQueryOptions as CreateQueryOptions, type UseQueryResult as CreateQueryResult, type DefinedUseBaseQueryResult as DefinedCreateBaseQueryResult, type DefinedUseInfiniteQueryResult as DefinedCreateInfiniteQueryResult, type DefinedUseQueryResult as DefinedCreateQueryResult, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type DefinedUseBaseQueryResult, type DefinedUseInfiniteQueryResult, type DefinedUseQueryResult, IsRestoringProvider, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type SolidInfiniteQueryOptions, type SolidMutationOptions, type SolidQueryOptions, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, type UseBaseMutationResult, type UseBaseQueryOptions, type UseBaseQueryResult, type UseInfiniteQueryOptions, type UseInfiniteQueryResult, type UseMutateAsyncFunction, type UseMutateFunction, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, useInfiniteQuery as createInfiniteQuery, useMutation as createMutation, useQueries as createQueries, useQuery as createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };
+export { type CreateBaseMutationResult, type CreateBaseQueryOptions, type CreateBaseQueryResult, type CreateInfiniteQueryOptions, type CreateInfiniteQueryResult, type CreateMutateAsyncFunction, type CreateMutateFunction, type CreateMutationOptions, type CreateMutationResult, type CreateQueryOptions, type CreateQueryResult, type DefaultOptions, type DefinedCreateBaseQueryResult, type DefinedCreateInfiniteQueryResult, type DefinedCreateQueryResult, type DefinedInitialDataInfiniteOptions, type DefinedInitialDataOptions, type InfiniteQueryObserverOptions, IsRestoringProvider, QueryClient, type QueryClientConfig, QueryClientContext, QueryClientProvider, type QueryClientProviderProps, type QueryObserverOptions, type SolidInfiniteQueryOptions, type SolidMutationOptions, type SolidQueryOptions, type UndefinedInitialDataInfiniteOptions, type UndefinedInitialDataOptions, createInfiniteQuery, createMutation, createQueries, createQuery, infiniteQueryOptions, queryOptions, useIsFetching, useIsMutating, useIsRestoring, useMutationState, useQueryClient };

build/index.js

@@ -1,2 +0,2 @@
-import { MutationObserver, replaceEqualDeep, QueriesObserver, hydrate, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
+import { QueryClient as QueryClient$1, MutationObserver, replaceEqualDeep, QueriesObserver, hydrate, notifyManager, QueryObserver, InfiniteQueryObserver } from '@tanstack/query-core';
 export * from '@tanstack/query-core';
@@ -8,2 +8,7 @@ import { createContext, useContext, createRenderEffect, onCleanup, createMemo, createSignal, createComputed, on, createEffect, mergeProps, createResource, batch, onMount } from 'solid-js';
 // src/index.ts
+var QueryClient = class extends QueryClient$1 {
+  constructor(config = {}) {
+    super(config);
+  }
+};
 var QueryClientContext = createContext(void 0);
@@ -48,3 +53,3 @@ var useQueryClient = (queryClient) => {
 
-// src/useBaseQuery.ts
+// src/createBaseQuery.ts
 function reconcileFn(store, result, reconcileOption, queryHash) {
@@ -86,3 +91,3 @@ if (reconcileOption === false) return result;
 };
-function useBaseQuery(options, Observer, queryClient) {
+function createBaseQuery(options, Observer, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
@@ -293,5 +298,5 @@ const isRestoring = useIsRestoring();
 
-// src/useQuery.ts
-function useQuery(options, queryClient) {
-  return useBaseQuery(
+// src/createQuery.ts
+function createQuery(options, queryClient) {
+  return createBaseQuery(
     createMemo(() => options()),
@@ -317,4 +322,4 @@ QueryObserver,
 }
-function useInfiniteQuery(options, queryClient) {
-  return useBaseQuery(
+function createInfiniteQuery(options, queryClient) {
+  return createBaseQuery(
     createMemo(() => options()),
@@ -330,3 +335,3 @@ InfiniteQueryObserver,
 }
-function useMutation(options, queryClient) {
+function createMutation(options, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
@@ -405,3 +410,3 @@ const observer = new MutationObserver(
 }
-function useQueries(queriesOptions, queryClient) {
+function createQueries(queriesOptions, queryClient) {
   const client = createMemo(() => useQueryClient(queryClient?.()));
@@ -524,2 +529,2 @@ const isRestoring = useIsRestoring();
 
-export { IsRestoringProvider, QueryClientContext, QueryClientProvider, useInfiniteQuery as createInfiniteQuery, useMutation as createMutation, useQueries as createQueries, useQuery as createQuery, infiniteQueryOptions, queryOptions, useInfiniteQuery, useIsFetching, useIsMutating, useIsRestoring, useMutation, useMutationState, useQueries, useQuery, useQueryClient };
+export { IsRestoringProvider, QueryClient, QueryClientContext, QueryClientProvider, createInfiniteQuery, createMutation, createQueries, createQuery, infiniteQueryOptions, queryOptions, useIsFetching, useIsMutating, useIsRestoring, useMutationState, useQueryClient };

package.json

 {
   "name": "@tanstack/solid-query",
-  "version": "5.71.7",
+  "version": "5.71.8",
   "description": "Primitives for managing, caching and syncing asynchronous and remote data in Solid",
@@ -5,0 +5,0 @@ "author": "tannerlinsley",

src/index.ts

@@ -8,43 +8,10 @@ /* istanbul ignore file */
 export * from './types'
-
+export { QueryClient } from './QueryClient'
 export type {
-  UseQueryOptions,
-  UseBaseQueryResult,
-  UseQueryResult,
-  DefinedUseBaseQueryResult,
-  DefinedUseQueryResult,
-  UseInfiniteQueryOptions,
-  UseInfiniteQueryResult,
-  DefinedUseInfiniteQueryResult,
-  UseMutationOptions,
-  UseMutateFunction,
-  UseMutateAsyncFunction,
-  UseBaseMutationResult,
-  UseMutationResult,
-  UseBaseQueryOptions,
-  SolidQueryOptions,
-  SolidInfiniteQueryOptions,
-  SolidMutationOptions,
-} from './types'
-
-// Compatibility types
-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'
@@ -62,4 +29,3 @@ export type {
 export { useIsFetching } from './useIsFetching'
-export { useInfiniteQuery } from './useInfiniteQuery'
-export { useInfiniteQuery as createInfiniteQuery } from './useInfiniteQuery'
+export { createInfiniteQuery } from './createInfiniteQuery'
 export { infiniteQueryOptions } from './infiniteQueryOptions'
@@ -70,8 +36,6 @@ export type {
 } 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'

src/QueryClientProvider.tsx

@@ -7,4 +7,3 @@ import {
 } from 'solid-js'
-import type { QueryClient } from '@tanstack/query-core'
-
+import type { QueryClient } from './QueryClient'
 import type { JSX } from 'solid-js'
@@ -11,0 +10,0 @@

src/types.ts

@@ -7,3 +7,2 @@ /* istanbul ignore file */
   DefinedQueryObserverResult,
-  InfiniteQueryObserverOptions,
   InfiniteQueryObserverResult,
@@ -16,9 +15,11 @@ MutateFunction,
   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,
@@ -42,3 +43,3 @@ TError = DefaultError,
    * @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.
@@ -54,3 +55,3 @@ */
   TQueryKey extends QueryKey = QueryKey,
-> extends UseBaseQueryOptions<
+> extends CreateBaseQueryOptions<
     TQueryFnData,
@@ -63,3 +64,3 @@ TError,
 
-export type UseQueryOptions<
+export type CreateQueryOptions<
   TQueryFnData = unknown,
@@ -73,3 +74,3 @@ TError = DefaultError,
 
-export type UseBaseQueryResult<
+export type CreateBaseQueryResult<
   TData = unknown,
@@ -79,8 +80,8 @@ TError = DefaultError,
 
-export type UseQueryResult<
+export type CreateQueryResult<
   TData = unknown,
   TError = DefaultError,
-> = UseBaseQueryResult<TData, TError>
+> = CreateBaseQueryResult<TData, TError>
 
-export type DefinedUseBaseQueryResult<
+export type DefinedCreateBaseQueryResult<
   TData = unknown,
@@ -90,6 +91,6 @@ TError = DefaultError,
 
-export type DefinedUseQueryResult<
+export type DefinedCreateQueryResult<
   TData = unknown,
   TError = DefaultError,
-> = DefinedUseBaseQueryResult<TData, TError>
+> = DefinedCreateBaseQueryResult<TData, TError>
 
@@ -125,3 +126,3 @@ /* --- Create Infinite Queries Types --- */
    * @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.
@@ -132,3 +133,3 @@ */
 
-export type UseInfiniteQueryOptions<
+export type CreateInfiniteQueryOptions<
   TQueryFnData = unknown,
@@ -150,3 +151,3 @@ TError = DefaultError,
 
-export type UseInfiniteQueryResult<
+export type CreateInfiniteQueryResult<
   TData = unknown,
@@ -156,3 +157,3 @@ TError = DefaultError,
 
-export type DefinedUseInfiniteQueryResult<
+export type DefinedCreateInfiniteQueryResult<
   TData = unknown,
@@ -173,3 +174,3 @@ TError = DefaultError,
 
-export type UseMutationOptions<
+export type CreateMutationOptions<
   TData = unknown,
@@ -181,3 +182,3 @@ TError = DefaultError,
 
-export type UseMutateFunction<
+export type CreateMutateFunction<
   TData = unknown,
@@ -191,3 +192,3 @@ TError = DefaultError,
 
-export type UseMutateAsyncFunction<
+export type CreateMutateAsyncFunction<
   TData = unknown,
@@ -199,3 +200,3 @@ TError = DefaultError,
 
-export type UseBaseMutationResult<
+export type CreateBaseMutationResult<
   TData = unknown,
@@ -207,8 +208,8 @@ TError = DefaultError,
   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,
@@ -218,2 +219,2 @@ TError = DefaultError,
   TContext = unknown,
-> = UseBaseMutationResult<TData, TError, TVariables, TContext>
+> = CreateBaseMutationResult<TData, TError, TVariables, TContext>

src/useIsFetching.ts

 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'
@@ -5,0 +6,0 @@

src/useIsMutating.ts

 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'
@@ -5,0 +6,0 @@

src/useMutationState.ts

@@ -9,5 +9,5 @@ import { createEffect, createMemo, createSignal, onCleanup } from 'solid-js'
   MutationState,
-  QueryClient,
 } from '@tanstack/query-core'
 import type { Accessor } from 'solid-js'
+import type { QueryClient } from './QueryClient'
 
@@ -14,0 +14,0 @@ type MutationStateOptions<TResult = MutationState> = {

src/useBaseQuery.ts

-// Had to disable the lint rule because isServer type is defined as false
-// in solid-js/web package. I'll create a GitHub issue with them to see
-// why that happens.
-import { hydrate, notifyManager } from '@tanstack/query-core'
-import { isServer } from 'solid-js/web'
-import {
-  createComputed,
-  createMemo,
-  createResource,
-  createSignal,
-  on,
-  onCleanup,
-} from 'solid-js'
-import { createStore, reconcile, unwrap } from 'solid-js/store'
-import { useQueryClient } from './QueryClientProvider'
-import { shouldThrowError } from './utils'
-import { useIsRestoring } from './isRestoring'
-import type { UseBaseQueryOptions } from './types'
-import type { Accessor, Signal } from 'solid-js'
-
-import type {
-  Query,
-  QueryClient,
-  QueryKey,
-  QueryObserver,
-  QueryObserverResult,
-} from '@tanstack/query-core'
-
-function reconcileFn<TData, TError>(
-  store: QueryObserverResult<TData, TError>,
-  result: QueryObserverResult<TData, TError>,
-  reconcileOption:
-    | string
-    | false
-    | ((oldData: TData | undefined, newData: TData) => TData),
-  queryHash?: string,
-): QueryObserverResult<TData, TError> {
-  if (reconcileOption === false) return result
-  if (typeof reconcileOption === 'function') {
-    const newData = reconcileOption(store.data, result.data as TData)
-    return { ...result, data: newData } as typeof result
-  }
-  let data = result.data
-  if (store.data === undefined) {
-    try {
-      data = structuredClone(data)
-    } catch (error) {
-      if (process.env.NODE_ENV !== 'production') {
-        if (error instanceof Error) {
-          console.warn(
-            `Unable to correctly reconcile data for query key: ${queryHash}. ` +
-              `Possibly because the query data contains data structures that aren't supported ` +
-              `by the 'structuredClone' algorithm. Consider using a callback function instead ` +
-              `to manage the reconciliation manually.\n\n Error Received: ${error.name} - ${error.message}`,
-          )
-        }
-      }
-    }
-  }
-  const newData = reconcile(data, { key: reconcileOption })(store.data)
-  return { ...result, data: newData } as typeof result
-}
-
-/**
- * Solid's `onHydrated` functionality will silently "fail" (hydrate with an empty object)
- * if the resource data is not serializable.
- */
-const hydratableObserverResult = <
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryKey extends QueryKey,
-  TDataHydratable,
->(
-  query: Query<TQueryFnData, TError, TData, TQueryKey>,
-  result: QueryObserverResult<TDataHydratable, TError>,
-) => {
-  if (!isServer) return result
-  const obj: any = {
-    ...unwrap(result),
-    // During SSR, functions cannot be serialized, so we need to remove them
-    // This is safe because we will add these functions back when the query is hydrated
-    refetch: undefined,
-  }
-
-  // If the query is an infinite query, we need to remove additional properties
-  if ('fetchNextPage' in result) {
-    obj.fetchNextPage = undefined
-    obj.fetchPreviousPage = undefined
-  }
-
-  // We will also attach the dehydrated state of the query to the result
-  // This will be removed on client after hydration
-  obj.hydrationData = {
-    state: query.state,
-    queryKey: query.queryKey,
-    queryHash: query.queryHash,
-    ...(query.meta && { meta: query.meta }),
-  }
-
-  return obj
-}
-
-// Base Query Function that is used to create the query.
-export function useBaseQuery<
-  TQueryFnData,
-  TError,
-  TData,
-  TQueryData,
-  TQueryKey extends QueryKey,
->(
-  options: Accessor<
-    UseBaseQueryOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>
-  >,
-  Observer: typeof QueryObserver,
-  queryClient?: Accessor<QueryClient>,
-) {
-  type ResourceData = QueryObserverResult<TData, TError>
-
-  const client = createMemo(() => 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
-  // Causing a time out error. To prevent this we will queue the unsubscribe if the cleanup is called
-  // before the resource has loaded
-  let unsubscribeQueued = false
-
-  const defaultedOptions = createMemo(() => {
-    const defaultOptions = client().defaultQueryOptions(options())
-    defaultOptions._optimisticResults = isRestoring()
-      ? 'isRestoring'
-      : 'optimistic'
-    defaultOptions.structuralSharing = false
-    if (isServer) {
-      defaultOptions.retry = false
-      defaultOptions.throwOnError = true
-    }
-    return defaultOptions
-  })
-  const initialOptions = defaultedOptions()
-
-  const [observer, setObserver] = createSignal(
-    new Observer(client(), defaultedOptions()),
-  )
-
-  let observerResult = observer().getOptimisticResult(defaultedOptions())
-  const [state, setState] =
-    createStore<QueryObserverResult<TData, TError>>(observerResult)
-
-  const createServerSubscriber = (
-    resolve: (
-      data: ResourceData | PromiseLike<ResourceData | undefined> | undefined,
-    ) => void,
-    reject: (reason?: any) => void,
-  ) => {
-    return observer().subscribe((result) => {
-      notifyManager.batchCalls(() => {
-        const query = observer().getCurrentQuery()
-        const unwrappedResult = hydratableObserverResult(query, result)
-
-        if (unwrappedResult.isError) {
-          reject(unwrappedResult.error)
-          unsubscribeIfQueued()
-        } else {
-          resolve(unwrappedResult)
-          unsubscribeIfQueued()
-        }
-      })()
-    })
-  }
-
-  const unsubscribeIfQueued = () => {
-    if (unsubscribeQueued) {
-      unsubscribe?.()
-      unsubscribeQueued = false
-    }
-  }
-
-  const createClientSubscriber = () => {
-    const obs = observer()
-    return obs.subscribe((result) => {
-      observerResult = result
-      queueMicrotask(() => {
-        if (unsubscribe) {
-          refetch()
-        }
-      })
-    })
-  }
-
-  function setStateWithReconciliation(res: typeof observerResult) {
-    const opts = observer().options
-    // @ts-expect-error - Reconcile option is not correctly typed internally
-    const reconcileOptions = opts.reconcile
-
-    setState((store) => {
-      return reconcileFn(
-        store,
-        res,
-        reconcileOptions === undefined ? false : reconcileOptions,
-        opts.queryHash,
-      )
-    })
-  }
-
-  function createDeepSignal<T>(): Signal<T> {
-    return [
-      () => state,
-      (v: any) => {
-        const unwrapped = unwrap(state)
-        if (typeof v === 'function') {
-          v = v(unwrapped)
-        }
-        // Hydration data exists on first load after SSR,
-        // and should be removed from the observer result
-        if (v?.hydrationData) {
-          const { hydrationData, ...rest } = v
-          v = rest
-        }
-        setStateWithReconciliation(v)
-      },
-    ] as Signal<T>
-  }
-
-  /**
-   * Unsubscribe is set lazily, so that we can subscribe after hydration when needed.
-   */
-  let unsubscribe: (() => void) | null = null
-
-  /*
-    Fixes #7275
-    In a few cases, the observer could unmount before the resource is loaded.
-    This leads to Suspense boundaries to be suspended indefinitely.
-    This resolver will be called when the observer is unmounting 
-    but the resource is still in a loading state
-  */
-  let resolver: ((value: ResourceData) => void) | null = null
-  const [queryResource, { refetch }] = createResource<ResourceData | undefined>(
-    () => {
-      const obs = observer()
-      return new Promise((resolve, reject) => {
-        resolver = resolve
-        if (isServer) {
-          unsubscribe = createServerSubscriber(resolve, reject)
-        } else if (!unsubscribe && !isRestoring()) {
-          unsubscribe = createClientSubscriber()
-        }
-        obs.updateResult()
-
-        if (
-          observerResult.isError &&
-          !observerResult.isFetching &&
-          !isRestoring() &&
-          shouldThrowError(obs.options.throwOnError, [
-            observerResult.error,
-            obs.getCurrentQuery(),
-          ])
-        ) {
-          setStateWithReconciliation(observerResult)
-          return reject(observerResult.error)
-        }
-        if (!observerResult.isLoading) {
-          resolver = null
-          return resolve(
-            hydratableObserverResult(obs.getCurrentQuery(), observerResult),
-          )
-        }
-
-        setStateWithReconciliation(observerResult)
-      })
-    },
-    {
-      storage: createDeepSignal,
-
-      get deferStream() {
-        return options().deferStream
-      },
-
-      /**
-       * If this resource was populated on the server (either sync render, or streamed in over time), onHydrated
-       * will be called. This is the point at which we can hydrate the query cache state, and setup the query subscriber.
-       *
-       * Leveraging onHydrated allows us to plug into the async and streaming support that solidjs resources already support.
-       *
-       * Note that this is only invoked on the client, for queries that were originally run on the server.
-       */
-      onHydrated(_k, info) {
-        if (info.value && 'hydrationData' in info.value) {
-          hydrate(client(), {
-            // @ts-expect-error - hydrationData is not correctly typed internally
-            queries: [{ ...info.value.hydrationData }],
-          })
-        }
-
-        if (unsubscribe) return
-        /**
-         * Do not refetch query on mount if query was fetched on server,
-         * even if `staleTime` is not set.
-         */
-        const newOptions = { ...initialOptions }
-        if (
-          (initialOptions.staleTime || !initialOptions.initialData) &&
-          info.value
-        ) {
-          newOptions.refetchOnMount = false
-        }
-        // Setting the options as an immutable object to prevent
-        // wonky behavior with observer subscriptions
-        observer().setOptions(newOptions)
-        setStateWithReconciliation(observer().getOptimisticResult(newOptions))
-        unsubscribe = createClientSubscriber()
-      },
-    },
-  )
-
-  createComputed(
-    on(
-      client,
-      (c) => {
-        if (unsubscribe) {
-          unsubscribe()
-        }
-        const newObserver = new Observer(c, defaultedOptions())
-        unsubscribe = createClientSubscriber()
-        setObserver(newObserver)
-      },
-      {
-        defer: true,
-      },
-    ),
-  )
-
-  createComputed(
-    on(
-      isRestoring,
-      (restoring) => {
-        if (!restoring && !isServer) {
-          refetch()
-        }
-      },
-      { defer: true },
-    ),
-  )
-
-  onCleanup(() => {
-    if (isServer && queryResource.loading) {
-      unsubscribeQueued = true
-      return
-    }
-    if (unsubscribe) {
-      unsubscribe()
-      unsubscribe = null
-    }
-    if (resolver && !isServer) {
-      resolver(observerResult)
-      resolver = null
-    }
-  })
-
-  createComputed(
-    on(
-      [observer, defaultedOptions],
-      ([obs, opts]) => {
-        obs.setOptions(opts)
-        setStateWithReconciliation(obs.getOptimisticResult(opts))
-        refetch()
-      },
-      { defer: true },
-    ),
-  )
-
-  const handler = {
-    get(
-      target: QueryObserverResult<TData, TError>,
-      prop: keyof QueryObserverResult<TData, TError>,
-    ): any {
-      if (prop === 'data') {
-        if (state.data !== undefined) {
-          return queryResource.latest?.data
-        }
-        return queryResource()?.data
-      }
-      return Reflect.get(target, prop)
-    },
-  }
-
-  return new Proxy(state, handler)
-}

src/useInfiniteQuery.ts

-import { InfiniteQueryObserver } from '@tanstack/query-core'
-import { createMemo } from 'solid-js'
-import { useBaseQuery } from './useBaseQuery'
-import type {
-  DefaultError,
-  InfiniteData,
-  QueryClient,
-  QueryKey,
-  QueryObserver,
-} from '@tanstack/query-core'
-
-import type {
-  DefinedUseInfiniteQueryResult,
-  UseInfiniteQueryOptions,
-  UseInfiniteQueryResult,
-} from './types'
-import type { Accessor } from 'solid-js'
-import type {
-  DefinedInitialDataInfiniteOptions,
-  UndefinedInitialDataInfiniteOptions,
-} from './infiniteQueryOptions'
-
-export function useInfiniteQuery<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  options: DefinedInitialDataInfiniteOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-  queryClient?: Accessor<QueryClient>,
-): DefinedUseInfiniteQueryResult<TData, TError>
-export function useInfiniteQuery<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  options: UndefinedInitialDataInfiniteOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-  queryClient?: Accessor<QueryClient>,
-): UseInfiniteQueryResult<TData, TError>
-
-export function useInfiniteQuery<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = InfiniteData<TQueryFnData>,
-  TQueryKey extends QueryKey = QueryKey,
-  TPageParam = unknown,
->(
-  options: UseInfiniteQueryOptions<
-    TQueryFnData,
-    TError,
-    TData,
-    TQueryKey,
-    TPageParam
-  >,
-  queryClient?: Accessor<QueryClient>,
-): UseInfiniteQueryResult<TData, TError> {
-  return useBaseQuery(
-    createMemo(() => options()),
-    InfiniteQueryObserver as typeof QueryObserver,
-    queryClient,
-  ) as UseInfiniteQueryResult<TData, TError>
-}

src/useMutation.ts

-import { MutationObserver } from '@tanstack/query-core'
-import { createComputed, createMemo, on, onCleanup } from 'solid-js'
-import { createStore } from 'solid-js/store'
-import { useQueryClient } from './QueryClientProvider'
-import { noop, shouldThrowError } from './utils'
-import type { DefaultError, QueryClient } from '@tanstack/query-core'
-import type {
-  UseMutateFunction,
-  UseMutationOptions,
-  UseMutationResult,
-} from './types'
-import type { Accessor } from 'solid-js'
-
-// HOOK
-export function useMutation<
-  TData = unknown,
-  TError = DefaultError,
-  TVariables = void,
-  TContext = unknown,
->(
-  options: UseMutationOptions<TData, TError, TVariables, TContext>,
-  queryClient?: Accessor<QueryClient>,
-): UseMutationResult<TData, TError, TVariables, TContext> {
-  const client = createMemo(() => useQueryClient(queryClient?.()))
-
-  const observer = new MutationObserver<TData, TError, TVariables, TContext>(
-    client(),
-    options(),
-  )
-
-  const mutate: UseMutateFunction<TData, TError, TVariables, TContext> = (
-    variables,
-    mutateOptions,
-  ) => {
-    observer.mutate(variables, mutateOptions).catch(noop)
-  }
-
-  const [state, setState] = createStore<
-    UseMutationResult<TData, TError, TVariables, TContext>
-  >({
-    ...observer.getCurrentResult(),
-    mutate,
-    mutateAsync: observer.getCurrentResult().mutate,
-  })
-
-  createComputed(() => {
-    observer.setOptions(options())
-  })
-
-  createComputed(
-    on(
-      () => state.status,
-      () => {
-        if (
-          state.isError &&
-          shouldThrowError(observer.options.throwOnError, [state.error])
-        ) {
-          throw state.error
-        }
-      },
-    ),
-  )
-
-  const unsubscribe = observer.subscribe((result) => {
-    setState({
-      ...result,
-      mutate,
-      mutateAsync: result.mutate,
-    })
-  })
-
-  onCleanup(unsubscribe)
-
-  return state
-}

src/useQueries.ts

-import { QueriesObserver } from '@tanstack/query-core'
-import { createStore, unwrap } from 'solid-js/store'
-import {
-  batch,
-  createComputed,
-  createMemo,
-  createRenderEffect,
-  createResource,
-  mergeProps,
-  on,
-  onCleanup,
-  onMount,
-} from 'solid-js'
-import { useQueryClient } from './QueryClientProvider'
-import { useIsRestoring } from './isRestoring'
-import { noop } from './utils'
-import type { SolidQueryOptions, UseQueryResult } from './types'
-import type { Accessor } from 'solid-js'
-import type {
-  DefaultError,
-  OmitKeyof,
-  QueriesObserverOptions,
-  QueriesPlaceholderDataFunction,
-  QueryClient,
-  QueryFunction,
-  QueryKey,
-  QueryObserverOptions,
-  QueryObserverResult,
-  ThrowOnError,
-} from '@tanstack/query-core'
-
-// This defines the `UseQueryOptions` that are accepted in `QueriesOptions` & `GetOptions`.
-// `placeholderData` function does not have a parameter
-type UseQueryOptionsForUseQueries<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
-> = OmitKeyof<
-  SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  'placeholderData' | 'suspense'
-> & {
-  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.
-   * It will not suspend when the data is loading.
-   * Setting `suspense` to `true` will be a no-op.
-   */
-  suspense?: boolean
-}
-
-// Avoid TS depth-limit error in case of large array literal
-type MAXIMUM_DEPTH = 20
-
-// Widen the type of the symbol to enable type inference even if skipToken is not immutable.
-type SkipTokenForUseQueries = symbol
-
-type GetOptions<T> =
-  // Part 1: responsible for applying explicit type parameter to function arguments, if object { queryFnData: TQueryFnData, error: TError, data: TData }
-  T extends {
-    queryFnData: infer TQueryFnData
-    error?: infer TError
-    data: infer TData
-  }
-    ? UseQueryOptionsForUseQueries<TQueryFnData, TError, TData>
-    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
-      ? UseQueryOptionsForUseQueries<TQueryFnData, TError>
-      : T extends { data: infer TData; error?: infer TError }
-        ? UseQueryOptionsForUseQueries<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>
-          : T extends [infer TQueryFnData, infer TError]
-            ? UseQueryOptionsForUseQueries<TQueryFnData, TError>
-            : T extends [infer TQueryFnData]
-              ? UseQueryOptionsForUseQueries<TQueryFnData>
-              : // Part 3: responsible for inferring and enforcing type if no explicit parameter was provided
-                T extends {
-                    queryFn?:
-                      | QueryFunction<infer TQueryFnData, infer TQueryKey>
-                      | SkipTokenForUseQueries
-                    select?: (data: any) => infer TData
-                    throwOnError?: ThrowOnError<any, infer TError, any, any>
-                  }
-                ? UseQueryOptionsForUseQueries<
-                    TQueryFnData,
-                    unknown extends TError ? DefaultError : TError,
-                    unknown extends TData ? TQueryFnData : TData,
-                    TQueryKey
-                  >
-                : // Fallback
-                  UseQueryOptionsForUseQueries
-
-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>
-    : T extends { queryFnData: infer TQueryFnData; error?: infer TError }
-      ? UseQueryResult<TQueryFnData, TError>
-      : T extends { data: infer TData; error?: infer TError }
-        ? UseQueryResult<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>
-          : T extends [infer TQueryFnData, infer TError]
-            ? UseQueryResult<TQueryFnData, TError>
-            : T extends [infer TQueryFnData]
-              ? UseQueryResult<TQueryFnData>
-              : // Part 3: responsible for mapping inferred type to results, if no explicit parameter was provided
-                T extends {
-                    queryFn?:
-                      | QueryFunction<infer TQueryFnData, any>
-                      | SkipTokenForUseQueries
-                    select?: (data: any) => infer TData
-                    throwOnError?: ThrowOnError<any, infer TError, any, any>
-                  }
-                ? UseQueryResult<
-                    unknown extends TData ? TQueryFnData : TData,
-                    unknown extends TError ? DefaultError : TError
-                  >
-                : // Fallback
-                  UseQueryResult
-
-/**
- * QueriesOptions reducer recursively unwraps function arguments to infer/enforce type param
- */
-type QueriesOptions<
-  T extends Array<any>,
-  TResult extends Array<any> = [],
-  TDepth extends ReadonlyArray<number> = [],
-> = TDepth['length'] extends MAXIMUM_DEPTH
-  ? Array<UseQueryOptionsForUseQueries>
-  : T extends []
-    ? []
-    : T extends [infer Head]
-      ? [...TResult, GetOptions<Head>]
-      : T extends [infer Head, ...infer Tail]
-        ? QueriesOptions<
-            [...Tail],
-            [...TResult, GetOptions<Head>],
-            [...TDepth, 1]
-          >
-        : ReadonlyArray<unknown> extends T
-          ? T
-          : // 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<
-                  infer TQueryFnData,
-                  infer TError,
-                  infer TData,
-                  infer TQueryKey
-                >
-              >
-            ? Array<
-                UseQueryOptionsForUseQueries<
-                  TQueryFnData,
-                  TError,
-                  TData,
-                  TQueryKey
-                >
-              >
-            : // Fallback
-              Array<UseQueryOptionsForUseQueries>
-
-/**
- * QueriesResults reducer recursively maps type param to results
- */
-type QueriesResults<
-  T extends Array<any>,
-  TResult extends Array<any> = [],
-  TDepth extends ReadonlyArray<number> = [],
-> = TDepth['length'] extends MAXIMUM_DEPTH
-  ? Array<UseQueryResult>
-  : T extends []
-    ? []
-    : T extends [infer Head]
-      ? [...TResult, GetResults<Head>]
-      : T extends [infer Head, ...infer Tail]
-        ? QueriesResults<
-            [...Tail],
-            [...TResult, GetResults<Head>],
-            [...TDepth, 1]
-          >
-        : { [K in keyof T]: GetResults<T[K]> }
-
-export function useQueries<
-  T extends Array<any>,
-  TCombinedResult extends QueriesResults<T> = QueriesResults<T>,
->(
-  queriesOptions: Accessor<{
-    queries:
-      | readonly [...QueriesOptions<T>]
-      | readonly [...{ [K in keyof T]: GetOptions<T[K]> }]
-    combine?: (result: QueriesResults<T>) => TCombinedResult
-  }>,
-  queryClient?: Accessor<QueryClient>,
-): TCombinedResult {
-  const client = createMemo(() => useQueryClient(queryClient?.()))
-  const isRestoring = useIsRestoring()
-
-  const defaultedQueries = createMemo(() =>
-    queriesOptions().queries.map((options) =>
-      mergeProps(
-        client().defaultQueryOptions(options as QueryObserverOptions),
-        {
-          get _optimisticResults() {
-            return isRestoring() ? 'isRestoring' : 'optimistic'
-          },
-        },
-      ),
-    ),
-  )
-
-  const observer = new QueriesObserver(
-    client(),
-    defaultedQueries(),
-    queriesOptions().combine
-      ? ({
-          combine: queriesOptions().combine,
-        } as QueriesObserverOptions<TCombinedResult>)
-      : undefined,
-  )
-
-  const [state, setState] = createStore<TCombinedResult>(
-    observer.getOptimisticResult(
-      defaultedQueries(),
-      (queriesOptions() as QueriesObserverOptions<TCombinedResult>).combine,
-    )[1](),
-  )
-
-  createRenderEffect(
-    on(
-      () => queriesOptions().queries.length,
-      () =>
-        setState(
-          observer.getOptimisticResult(
-            defaultedQueries(),
-            (queriesOptions() as QueriesObserverOptions<TCombinedResult>)
-              .combine,
-          )[1](),
-        ),
-    ),
-  )
-
-  const dataResources = createMemo(
-    on(
-      () => state.length,
-      () =>
-        state.map((queryRes) => {
-          const dataPromise = () =>
-            new Promise((resolve) => {
-              if (queryRes.isFetching && queryRes.isLoading) return
-              resolve(unwrap(queryRes.data))
-            })
-          return createResource(dataPromise)
-        }),
-    ),
-  )
-
-  batch(() => {
-    const dataResources_ = dataResources()
-    for (let index = 0; index < dataResources_.length; index++) {
-      const dataResource = dataResources_[index]!
-      dataResource[1].mutate(() => unwrap(state[index]!.data))
-      dataResource[1].refetch()
-    }
-  })
-
-  let taskQueue: Array<() => void> = []
-  const subscribeToObserver = () =>
-    observer.subscribe((result) => {
-      taskQueue.push(() => {
-        batch(() => {
-          const dataResources_ = dataResources()
-          for (let index = 0; index < dataResources_.length; index++) {
-            const dataResource = dataResources_[index]!
-            const unwrappedResult = { ...unwrap(result[index]) }
-            // @ts-expect-error typescript pedantry regarding the possible range of index
-            setState(index, unwrap(unwrappedResult))
-            dataResource[1].mutate(() => unwrap(state[index]!.data))
-            dataResource[1].refetch()
-          }
-        })
-      })
-
-      queueMicrotask(() => {
-        const taskToRun = taskQueue.pop()
-        if (taskToRun) taskToRun()
-        taskQueue = []
-      })
-    })
-
-  let unsubscribe = noop
-  createComputed<() => void>((cleanup) => {
-    cleanup?.()
-    unsubscribe = isRestoring() ? noop : subscribeToObserver()
-    // cleanup needs to be scheduled after synchronous effects take place
-    return () => queueMicrotask(unsubscribe)
-  })
-  onCleanup(unsubscribe)
-
-  onMount(() => {
-    observer.setQueries(
-      defaultedQueries(),
-      queriesOptions().combine
-        ? ({
-            combine: queriesOptions().combine,
-          } as QueriesObserverOptions<TCombinedResult>)
-        : undefined,
-    )
-  })
-
-  createComputed(() => {
-    observer.setQueries(
-      defaultedQueries(),
-      queriesOptions().combine
-        ? ({
-            combine: queriesOptions().combine,
-          } as QueriesObserverOptions<TCombinedResult>)
-        : undefined,
-    )
-  })
-
-  const handler = (index: number) => ({
-    get(target: QueryObserverResult, prop: keyof QueryObserverResult): any {
-      if (prop === 'data') {
-        return dataResources()[index]![0]()
-      }
-      return Reflect.get(target, prop)
-    },
-  })
-
-  const getProxies = () =>
-    state.map((s, index) => {
-      return new Proxy(s, handler(index))
-    })
-
-  const [proxyState, setProxyState] = createStore(getProxies())
-  createRenderEffect(() => setProxyState(getProxies()))
-
-  return proxyState as TCombinedResult
-}

src/useQuery.ts

-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 type { Accessor } from 'solid-js'
-import type {
-  DefinedUseQueryResult,
-  UseQueryOptions,
-  UseQueryResult,
-} from './types'
-import type {
-  DefinedInitialDataOptions,
-  UndefinedInitialDataOptions,
-} from './queryOptions'
-
-export function useQuery<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
-  queryClient?: () => QueryClient,
-): UseQueryResult<TData, TError>
-
-export function useQuery<
-  TQueryFnData = unknown,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
-  queryClient?: () => QueryClient,
-): DefinedUseQueryResult<TData, TError>
-export function useQuery<
-  TQueryFnData,
-  TError = DefaultError,
-  TData = TQueryFnData,
-  TQueryKey extends QueryKey = QueryKey,
->(
-  options: UseQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  queryClient?: Accessor<QueryClient>,
-) {
-  return useBaseQuery(
-    createMemo(() => options()),
-    QueryObserver,
-    queryClient,
-  )
-}

New alerts

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Fixed alerts

Environment variable access

Supply chain risk

Package accesses environment variables, which may be a sign of credential stuffing or data theft.

Found 1 instance in 1 package

Long strings

Supply chain risk

Contains long string literals, which may be a sign of obfuscated or packed code.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

155482

3.44%

Number of package files

25

4.17%

Lines of code

3807

2.5%

No dependency changes