@tanstack/solid-query 4.24.10 → 5.0.0-alpha.0

package/src/createQuery.ts

@@ -1,157 +1,72 @@
-import type { QueryFunction, QueryOptions } from '@tanstack/query-core'
+import type {
+  QueryClient,
+  QueryKey,
+  RegisteredError,
+} from '@tanstack/query-core'
 import { QueryObserver } from '@tanstack/query-core'
+import { createMemo } from 'solid-js'
+import { createBaseQuery } from './createBaseQuery'
 import type {
   CreateQueryOptions,
   CreateQueryResult,
   DefinedCreateQueryResult,
-  SolidQueryKey,
+  FunctionedParams,
+  SolidQueryOptions,
 } from './types'
-import { createComputed } from 'solid-js'
-import { createStore } from 'solid-js/store'
-import { parseQueryArgs } from './utils'
-import { createBaseQuery } from './createBaseQuery'
 
-// There are several ways to create a query.
-// 1. createQuery(options: CreateQueryOptions)
-// 2. createQuery(querykey: () => Serializable[], options: CreateQueryOptions)
-// 3. createQuery(querykey: () => Serializable[], queryFunc: Fetcher Function,  options: CreateQueryOptions)
-// 4. The fourth overload is a combination of all three function params
-export function createQuery<
+type UndefinedInitialDataOptions<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
-  TQueryKey extends SolidQueryKey = SolidQueryKey,
->(
-  options: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'initialData'
-  > & {
-    initialData?: () => undefined
-  },
-): CreateQueryResult<TData, TError>
-export function createQuery<
+  TQueryKey extends QueryKey = QueryKey,
+> = FunctionedParams<
+  SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
+    initialData?: undefined
+  }
+>
+
+type DefinedInitialDataOptions<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
-  TQueryKey extends SolidQueryKey = SolidQueryKey,
->(
-  options: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'initialData'
-  > & {
+  TQueryKey extends QueryKey = QueryKey,
+> = FunctionedParams<
+  SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey> & {
     initialData: TQueryFnData | (() => TQueryFnData)
-  },
-): DefinedCreateQueryResult<TData, TError>
-export function createQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends SolidQueryKey = SolidQueryKey,
->(
-  options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-): CreateQueryResult<TData, TError>
-export function createQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends SolidQueryKey = SolidQueryKey,
->(
-  queryKey: TQueryKey,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey' | 'initialData'
-  > & { initialData?: () => undefined },
-): CreateQueryResult<TData, TError>
-export function createQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends SolidQueryKey = SolidQueryKey,
->(
-  queryKey: TQueryKey,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey' | 'initialData'
-  > & { initialData: TQueryFnData | (() => TQueryFnData) },
-): DefinedCreateQueryResult<TData, TError>
-export function createQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends SolidQueryKey = SolidQueryKey,
->(
-  queryKey: TQueryKey,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey'
-  >,
-): CreateQueryResult<TData, TError>
+  }
+>
+
 export function createQuery<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
-  TQueryKey extends SolidQueryKey = SolidQueryKey,
+  TQueryKey extends QueryKey = QueryKey,
 >(
-  queryKey: TQueryKey,
-  // TODO(lukemurray): not sure if we want to use return type here
-  queryFn: QueryFunction<TQueryFnData, ReturnType<TQueryKey>>,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey' | 'queryFn' | 'initialData'
-  > & { initialData?: () => undefined },
+  options: UndefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: () => QueryClient,
 ): CreateQueryResult<TData, TError>
+
 export function createQuery<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
-  TQueryKey extends SolidQueryKey = SolidQueryKey,
+  TQueryKey extends QueryKey = QueryKey,
 >(
-  queryKey: TQueryKey,
-  queryFn: QueryFunction<TQueryFnData, ReturnType<TQueryKey>>,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey' | 'queryFn' | 'initialData'
-  > & { initialData: TQueryFnData | (() => TQueryFnData) },
+  options: DefinedInitialDataOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: () => QueryClient,
 ): DefinedCreateQueryResult<TData, TError>
-export function createQuery<
-  TQueryFnData = unknown,
-  TError = unknown,
-  TData = TQueryFnData,
-  TQueryKey extends SolidQueryKey = SolidQueryKey,
->(
-  queryKey: TQueryKey,
-  queryFn: QueryFunction<TQueryFnData, ReturnType<TQueryKey>>,
-  options?: Omit<
-    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-    'queryKey' | 'queryFn'
-  >,
-): CreateQueryResult<TData, TError>
 export function createQuery<
   TQueryFnData,
-  TError,
+  TError = RegisteredError,
   TData = TQueryFnData,
-  TQueryKey extends SolidQueryKey = SolidQueryKey,
+  TQueryKey extends QueryKey = QueryKey,
 >(
-  arg1: TQueryKey | CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  arg2?:
-    | QueryFunction<TQueryFnData, ReturnType<TQueryKey>>
-    | CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-  arg3?: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
-): CreateQueryResult<TData, TError> {
-  // The parseQuery Args functions helps normalize the arguments into the correct form.
-  // Whatever the parameters are, they are normalized into the correct form.
-  const [parsedOptions, setParsedOptions] = createStore(
-    parseQueryArgs(arg1, arg2, arg3),
-  )
-
-  // Watch for changes in the options and update the parsed options.
-  createComputed(() => {
-    const newParsedOptions = parseQueryArgs(arg1, arg2, arg3)
-    setParsedOptions(newParsedOptions)
-  })
-
+  options: CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+  queryClient?: () => QueryClient,
+) {
   return createBaseQuery(
-    parsedOptions as QueryOptions<any, any, any, ReturnType<TQueryKey>>,
+    createMemo(() => options()),
     QueryObserver,
+    queryClient,
   )
 }

package/src/index.ts

@@ -1,5 +1,8 @@
 /* istanbul ignore file */
 
+// Side Effects
+import './setBatchUpdatesFn'
+
 // Re-export core
 export * from '@tanstack/query-core'
 
@@ -7,13 +10,13 @@ export * from '@tanstack/query-core'
 export * from './types'
 export { createQuery } from './createQuery'
 export {
-  defaultContext,
+  QueryClientContext,
   QueryClientProvider,
   useQueryClient,
 } from './QueryClientProvider'
 export type { QueryClientProviderProps } from './QueryClientProvider'
 export { useIsFetching } from './useIsFetching'
-export { useIsMutating } from './useIsMutating'
-export { createMutation } from './createMutation'
 export { createInfiniteQuery } from './createInfiniteQuery'
+export { createMutation } from './createMutation'
+export { useIsMutating } from './useIsMutating'
 export { createQueries } from './createQueries'

package/src/setBatchUpdatesFn.ts

@@ -0,0 +1,4 @@
+import { notifyManager } from '@tanstack/query-core'
+import { batch } from 'solid-js'
+
+notifyManager.setBatchNotifyFunction(batch)

package/src/types.ts

@@ -1,8 +1,6 @@
 /* istanbul ignore file */
 
-import type { Context } from 'solid-js'
 import type {
-  QueryClient,
   QueryKey,
   QueryObserverOptions,
   QueryObserverResult,
@@ -12,120 +10,136 @@ import type {
   DefinedQueryObserverResult,
   InfiniteQueryObserverOptions,
   InfiniteQueryObserverResult,
-  QueryFilters,
-  QueryOptions,
+  WithRequired,
+  RegisteredError,
 } from '@tanstack/query-core'
 
-export interface ContextOptions {
-  /**
-   * Use this to pass your Solid Query context. Otherwise, `defaultContext` will be used.
-   */
-  context?: Context<QueryClient | undefined>
-}
-
-/* --- Create Query and Create Base Query  Types --- */
-export type SolidQueryKey = () => readonly unknown[]
+export type FunctionedParams<T> = () => T
 
 export interface CreateBaseQueryOptions<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
   TQueryData = TQueryFnData,
   TQueryKey extends QueryKey = QueryKey,
-> extends ContextOptions,
-    QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {}
+> extends WithRequired<
+    QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey>,
+    'queryKey'
+  > {
+  deferStream?: boolean
+}
 
-export interface CreateQueryOptions<
+export interface SolidQueryOptions<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
-  TQueryKey extends () => readonly unknown[] = SolidQueryKey,
-> extends Omit<
+  TQueryKey extends QueryKey = QueryKey,
+> extends WithRequired<
     CreateBaseQueryOptions<
       TQueryFnData,
       TError,
       TData,
       TQueryFnData,
-      ReturnType<TQueryKey>
+      TQueryKey
     >,
     'queryKey'
-  > {
-  queryKey?: TQueryKey
-}
+  > {}
+
+export type CreateQueryOptions<
+  TQueryFnData = unknown,
+  TError = RegisteredError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> = FunctionedParams<SolidQueryOptions<TQueryFnData, TError, TData, TQueryKey>>
+
+/* --- Create Query and Create Base Query  Types --- */
 
 export type CreateBaseQueryResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
 > = QueryObserverResult<TData, TError>
 
 export type CreateQueryResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
 > = CreateBaseQueryResult<TData, TError>
 
 export type DefinedCreateBaseQueryResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
 > = DefinedQueryObserverResult<TData, TError>
 
 export type DefinedCreateQueryResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
 > = DefinedCreateBaseQueryResult<TData, TError>
 
-export type ParseQueryArgs<
-  TOptions extends Omit<
-    QueryOptions<any, any, any, ReturnType<TQueryKey>>,
-    'queryKey'
-  > & {
-    queryKey?: TQueryKey
-  },
-  TQueryKey extends () => readonly unknown[] = SolidQueryKey,
-> = TOptions['queryKey'] extends () => infer R
-  ? Omit<TOptions, 'queryKey'> & { queryKey?: R }
-  : TOptions
-
 /* --- Create Infinite Queries Types --- */
-export interface CreateInfiniteQueryOptions<
+export interface SolidInfiniteQueryOptions<
   TQueryFnData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TData = TQueryFnData,
   TQueryData = TQueryFnData,
-  TQueryKey extends () => readonly unknown[] = SolidQueryKey,
-> extends ContextOptions,
-    Omit<
-      InfiniteQueryObserverOptions<
-        TQueryFnData,
-        TError,
-        TData,
-        TQueryData,
-        ReturnType<TQueryKey>
-      >,
-      'queryKey'
-    > {
-  queryKey?: TQueryKey
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+> extends Omit<
+    InfiniteQueryObserverOptions<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryData,
+      TQueryKey,
+      TPageParam
+    >,
+    'queryKey'
+  > {
+  queryKey: TQueryKey
+  deferStream?: boolean
 }
 
+export type CreateInfiniteQueryOptions<
+  TQueryFnData = unknown,
+  TError = RegisteredError,
+  TData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+  TPageParam = unknown,
+> = FunctionedParams<
+  SolidInfiniteQueryOptions<
+    TQueryFnData,
+    TError,
+    TData,
+    TQueryFnData,
+    TQueryKey,
+    TPageParam
+  >
+>
+
 export type CreateInfiniteQueryResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
 > = InfiniteQueryObserverResult<TData, TError>
 
 /* --- Create Mutation Types --- */
-export interface CreateMutationOptions<
+export interface SolidMutationOptions<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TVariables = void,
   TContext = unknown,
-> extends ContextOptions,
-    Omit<
-      MutationObserverOptions<TData, TError, TVariables, TContext>,
-      '_defaulted' | 'variables'
-    > {}
+> extends Omit<
+    MutationObserverOptions<TData, TError, TVariables, TContext>,
+    '_defaulted' | 'variables'
+  > {}
+
+export type CreateMutationOptions<
+  TData = unknown,
+  TError = RegisteredError,
+  TVariables = void,
+  TContext = unknown,
+> = FunctionedParams<SolidMutationOptions<TData, TError, TVariables, TContext>>
 
 export type CreateMutateFunction<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TVariables = void,
   TContext = unknown,
 > = (
@@ -134,14 +148,14 @@ export type CreateMutateFunction<
 
 export type CreateMutateAsyncFunction<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TVariables = void,
   TContext = unknown,
 > = MutateFunction<TData, TError, TVariables, TContext>
 
 export type CreateBaseMutationResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TVariables = unknown,
   TContext = unknown,
 > = Override<
@@ -153,17 +167,9 @@ export type CreateBaseMutationResult<
 
 export type CreateMutationResult<
   TData = unknown,
-  TError = unknown,
+  TError = RegisteredError,
   TVariables = unknown,
   TContext = unknown,
 > = CreateBaseMutationResult<TData, TError, TVariables, TContext>
 
 type Override<A, B> = { [K in keyof A]: K extends keyof B ? B[K] : A[K] }
-
-/* --- Use Is Fetching Types --- */
-export interface SolidQueryFilters extends Omit<QueryFilters, 'queryKey'> {
-  queryKey?: SolidQueryKey
-}
-
-export type ParseFilterArgs<T extends SolidQueryFilters> =
-  T['queryKey'] extends () => infer R ? T & { queryKey: R } : T

package/src/useIsFetching.ts

@@ -1,58 +1,26 @@
-import type { QueryFilters } from '@tanstack/query-core'
-
-import type { ContextOptions, SolidQueryKey, SolidQueryFilters } from './types'
-import { useQueryClient } from './QueryClientProvider'
+import type { QueryClient, QueryFilters } from '@tanstack/query-core'
 import type { Accessor } from 'solid-js'
-import { createSignal, onCleanup, createComputed, createMemo } from 'solid-js'
-import { parseFilterArgs } from './utils'
-
-interface Options extends ContextOptions {}
-
-export function useIsFetching(
-  filters?: SolidQueryFilters,
-  options?: Options,
-): Accessor<number>
-export function useIsFetching(
-  queryKey?: SolidQueryKey,
-  filters?: SolidQueryFilters,
-  options?: Options,
-): Accessor<number>
-export function useIsFetching(
-  arg1?: SolidQueryKey | SolidQueryFilters,
-  arg2?: SolidQueryFilters | Options,
-  arg3?: Options,
-): Accessor<number> {
-  const [filtersObj, optionsObj = {}] = parseFilterArgs(arg1, arg2, arg3)
+import { createMemo, createSignal, onCleanup } from 'solid-js'
+import { useQueryClient } from './QueryClientProvider'
 
-  const [filters, setFilters] = createSignal(filtersObj)
-  const [options, setOptions] = createSignal(optionsObj)
+type Options = () => {
+  filters?: QueryFilters
+  queryClient?: QueryClient
+}
 
-  const queryClient = createMemo(() =>
-    useQueryClient({ context: options().context }),
-  )
+export function useIsFetching(options: Options = () => ({})): Accessor<number> {
+  const queryClient = createMemo(() => useQueryClient(options().queryClient))
   const queryCache = createMemo(() => queryClient().getQueryCache())
 
   const [fetches, setFetches] = createSignal(
-    queryClient().isFetching(filters as QueryFilters),
+    queryClient().isFetching(options().filters),
   )
 
-  createComputed(() => {
-    const [newFiltersObj, newOptionsObj = {}] = parseFilterArgs(
-      arg1,
-      arg2,
-      arg3,
-    )
-    setFilters(newFiltersObj)
-    setOptions(newOptionsObj)
-  })
-
   const unsubscribe = queryCache().subscribe(() => {
-    setFetches(queryClient().isFetching(filters() as QueryFilters))
+    setFetches(queryClient().isFetching(options().filters))
   })
 
-  onCleanup(() => {
-    unsubscribe()
-  })
+  onCleanup(unsubscribe)
 
   return fetches
 }

package/src/useIsMutating.ts

@@ -1,42 +1,26 @@
-import type { MutationKey, MutationFilters } from '@tanstack/query-core'
-import { parseMutationFilterArgs } from '@tanstack/query-core'
-import type { ContextOptions } from './types'
+import type { MutationFilters, QueryClient } from '@tanstack/query-core'
 import { useQueryClient } from './QueryClientProvider'
 import type { Accessor } from 'solid-js'
-import { createSignal, onCleanup } from 'solid-js'
+import { createSignal, onCleanup, createMemo } from 'solid-js'
 
-interface Options extends ContextOptions {}
-
-export function useIsMutating(
-  filters?: MutationFilters,
-  options?: Options,
-): Accessor<number>
-export function useIsMutating(
-  mutationKey?: MutationKey,
-  filters?: Omit<MutationFilters, 'mutationKey'>,
-  options?: Options,
-): Accessor<number>
-export function useIsMutating(
-  arg1?: MutationKey | MutationFilters,
-  arg2?: Omit<MutationFilters, 'mutationKey'> | Options,
-  arg3?: Options,
-): Accessor<number> {
-  const [filters, options = {}] = parseMutationFilterArgs(arg1, arg2, arg3)
+type Options = () => {
+  filters?: MutationFilters
+  queryClient?: QueryClient
+}
 
-  const queryClient = useQueryClient({ context: options.context })
-  const mutationCache = queryClient.getMutationCache()
+export function useIsMutating(options: Options = () => ({})): Accessor<number> {
+  const queryClient = createMemo(() => useQueryClient(options().queryClient))
+  const mutationCache = createMemo(() => queryClient().getMutationCache())
 
   const [mutations, setMutations] = createSignal(
-    queryClient.isMutating(filters),
+    queryClient().isMutating(options().filters),
   )
 
-  const unsubscribe = mutationCache.subscribe((_result) => {
-    setMutations(queryClient.isMutating(filters))
+  const unsubscribe = mutationCache().subscribe((_result) => {
+    setMutations(queryClient().isMutating(options().filters))
   })
 
-  onCleanup(() => {
-    unsubscribe()
-  })
+  onCleanup(unsubscribe)
 
   return mutations
 }