@tanstack/solid-query 4.4.0

package/src/createQuery.ts

@@ -0,0 +1,157 @@
+import type { QueryFunction, QueryOptions } from '@tanstack/query-core'
+import { QueryObserver } from '@tanstack/query-core'
+import type {
+  CreateQueryOptions,
+  CreateQueryResult,
+  DefinedCreateQueryResult,
+  SolidQueryKey,
+} 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<
+  TQueryFnData = unknown,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends SolidQueryKey = SolidQueryKey,
+>(
+  options: Omit<
+    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+    'initialData'
+  > & {
+    initialData?: () => undefined
+  },
+): CreateQueryResult<TData, TError>
+export function createQuery<
+  TQueryFnData = unknown,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends SolidQueryKey = SolidQueryKey,
+>(
+  options: Omit<
+    CreateQueryOptions<TQueryFnData, TError, TData, TQueryKey>,
+    'initialData'
+  > & {
+    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,
+  TData = TQueryFnData,
+  TQueryKey extends SolidQueryKey = SolidQueryKey,
+>(
+  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 },
+): CreateQueryResult<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' | 'initialData'
+  > & { initialData: TQueryFnData | (() => TQueryFnData) },
+): 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,
+  TData = TQueryFnData,
+  TQueryKey extends SolidQueryKey = SolidQueryKey,
+>(
+  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)
+  })
+
+  return createBaseQuery(
+    parsedOptions as QueryOptions<any, any, any, ReturnType<TQueryKey>>,
+    QueryObserver,
+  )
+}

package/src/index.ts

@@ -0,0 +1,17 @@
+// Re-export core
+export * from '@tanstack/query-core'
+
+// Solid Query
+export * from './types'
+export { createQuery } from './createQuery'
+export {
+  defaultContext,
+  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 { createQueries } from './createQueries'

package/src/types.ts

@@ -0,0 +1,167 @@
+import type { Context } from 'solid-js'
+import type {
+  QueryClient,
+  QueryKey,
+  QueryObserverOptions,
+  QueryObserverResult,
+  MutateFunction,
+  MutationObserverOptions,
+  MutationObserverResult,
+  DefinedQueryObserverResult,
+  InfiniteQueryObserverOptions,
+  InfiniteQueryObserverResult,
+  QueryFilters,
+  QueryOptions,
+} 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 interface CreateBaseQueryOptions<
+  TQueryFnData = unknown,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends QueryKey = QueryKey,
+> extends ContextOptions,
+    QueryObserverOptions<TQueryFnData, TError, TData, TQueryData, TQueryKey> {}
+
+export interface CreateQueryOptions<
+  TQueryFnData = unknown,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryKey extends () => readonly unknown[] = SolidQueryKey,
+> extends Omit<
+    CreateBaseQueryOptions<
+      TQueryFnData,
+      TError,
+      TData,
+      TQueryFnData,
+      ReturnType<TQueryKey>
+    >,
+    'queryKey'
+  > {
+  queryKey?: TQueryKey
+}
+
+export type CreateBaseQueryResult<
+  TData = unknown,
+  TError = unknown,
+> = QueryObserverResult<TData, TError>
+
+export type CreateQueryResult<
+  TData = unknown,
+  TError = unknown,
+> = CreateBaseQueryResult<TData, TError>
+
+export type DefinedCreateBaseQueryResult<
+  TData = unknown,
+  TError = unknown,
+> = DefinedQueryObserverResult<TData, TError>
+
+export type DefinedCreateQueryResult<
+  TData = unknown,
+  TError = unknown,
+> = 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<
+  TQueryFnData = unknown,
+  TError = unknown,
+  TData = TQueryFnData,
+  TQueryData = TQueryFnData,
+  TQueryKey extends () => readonly unknown[] = SolidQueryKey,
+> extends ContextOptions,
+    Omit<
+      InfiniteQueryObserverOptions<
+        TQueryFnData,
+        TError,
+        TData,
+        TQueryData,
+        ReturnType<TQueryKey>
+      >,
+      'queryKey'
+    > {
+  queryKey?: TQueryKey
+}
+
+export type CreateInfiniteQueryResult<
+  TData = unknown,
+  TError = unknown,
+> = InfiniteQueryObserverResult<TData, TError>
+
+/* --- Create Mutation Types --- */
+export interface CreateMutationOptions<
+  TData = unknown,
+  TError = unknown,
+  TVariables = void,
+  TContext = unknown,
+> extends ContextOptions,
+    Omit<
+      MutationObserverOptions<TData, TError, TVariables, TContext>,
+      '_defaulted' | 'variables'
+    > {}
+
+export type CreateMutateFunction<
+  TData = unknown,
+  TError = unknown,
+  TVariables = void,
+  TContext = unknown,
+> = (
+  ...args: Parameters<MutateFunction<TData, TError, TVariables, TContext>>
+) => void
+
+export type CreateMutateAsyncFunction<
+  TData = unknown,
+  TError = unknown,
+  TVariables = void,
+  TContext = unknown,
+> = MutateFunction<TData, TError, TVariables, TContext>
+
+export type CreateBaseMutationResult<
+  TData = unknown,
+  TError = unknown,
+  TVariables = unknown,
+  TContext = unknown,
+> = Override<
+  MutationObserverResult<TData, TError, TVariables, TContext>,
+  { mutate: CreateMutateFunction<TData, TError, TVariables, TContext> }
+> & {
+  mutateAsync: CreateMutateAsyncFunction<TData, TError, TVariables, TContext>
+}
+
+export type CreateMutationResult<
+  TData = unknown,
+  TError = unknown,
+  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

@@ -0,0 +1,58 @@
+import type { QueryFilters } from '@tanstack/query-core'
+
+import type { ContextOptions, SolidQueryKey, SolidQueryFilters } from './types'
+import { useQueryClient } from './QueryClientProvider'
+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)
+
+  const [filters, setFilters] = createSignal(filtersObj)
+  const [options, setOptions] = createSignal(optionsObj)
+
+  const queryClient = createMemo(() =>
+    useQueryClient({ context: options().context }),
+  )
+  const queryCache = createMemo(() => queryClient().getQueryCache())
+
+  const [fetches, setFetches] = createSignal(
+    queryClient().isFetching(filters as QueryFilters),
+  )
+
+  createComputed(() => {
+    const [newFiltersObj, newOptionsObj = {}] = parseFilterArgs(
+      arg1,
+      arg2,
+      arg3,
+    )
+    setFilters(newFiltersObj)
+    setOptions(newOptionsObj)
+  })
+
+  const unsubscribe = queryCache().subscribe(() => {
+    setFetches(queryClient().isFetching(filters() as QueryFilters))
+  })
+
+  onCleanup(() => {
+    unsubscribe()
+  })
+
+  return fetches
+}

package/src/useIsMutating.ts

@@ -0,0 +1,42 @@
+import type { MutationKey, MutationFilters } from '@tanstack/query-core'
+import { parseMutationFilterArgs } from '@tanstack/query-core'
+import type { ContextOptions } from './types'
+import { useQueryClient } from './QueryClientProvider'
+import type { Accessor } from 'solid-js'
+import { createSignal, onCleanup } 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)
+
+  const queryClient = useQueryClient({ context: options.context })
+  const mutationCache = queryClient.getMutationCache()
+
+  const [mutations, setMutations] = createSignal(
+    queryClient.isMutating(filters),
+  )
+
+  const unsubscribe = mutationCache.subscribe((_result) => {
+    setMutations(queryClient.isMutating(filters))
+  })
+
+  onCleanup(() => {
+    unsubscribe()
+  })
+
+  return mutations
+}

package/src/utils.ts

@@ -0,0 +1,85 @@
+import type {
+  SolidQueryKey,
+  SolidQueryFilters,
+  ParseFilterArgs,
+  ParseQueryArgs,
+} from './types'
+import type { QueryFunction, QueryOptions } from '@tanstack/query-core'
+
+export function isQueryKey(value: unknown): value is SolidQueryKey {
+  return typeof value === 'function'
+}
+
+// The parseQuery Args functions helps normalize the arguments into the correct form.
+// Whatever the parameters are, they are normalized into the correct form.
+export function parseQueryArgs<
+  TOptions extends Omit<
+    QueryOptions<any, any, any, ReturnType<TQueryKey>>,
+    'queryKey'
+  > & {
+    queryKey?: TQueryKey
+  },
+  TQueryKey extends () => readonly unknown[] = SolidQueryKey,
+>(
+  arg1: TQueryKey | TOptions,
+  arg2?: QueryFunction<any, ReturnType<TQueryKey>> | TOptions,
+  arg3?: TOptions,
+): ParseQueryArgs<TOptions, TQueryKey> {
+  if (!isQueryKey(arg1)) {
+    const { queryKey: solidKey, ...opts } = arg1 as any
+    if (solidKey) {
+      return {
+        ...opts,
+        queryKey: solidKey(),
+      }
+    }
+    return arg1 as any
+  }
+
+  if (typeof arg2 === 'function') {
+    return { ...arg3, queryKey: arg1(), queryFn: arg2 } as any
+  }
+
+  return { ...arg2, queryKey: arg1() } as any
+}
+
+export function parseFilterArgs<
+  TFilters extends SolidQueryFilters,
+  TOptions = unknown,
+>(
+  arg1?: SolidQueryKey | TFilters,
+  arg2?: TFilters | TOptions,
+  arg3?: TOptions,
+): [ParseFilterArgs<TFilters>, TOptions | undefined] {
+  return (
+    isQueryKey(arg1)
+      ? [{ ...arg2, queryKey: arg1() }, arg3]
+      : [{ ...arg1, queryKey: arg1?.queryKey?.() }, arg2]
+  ) as [ParseFilterArgs<TFilters>, TOptions]
+}
+
+export function shouldThrowError<T extends (...args: any[]) => boolean>(
+  _useErrorBoundary: boolean | T | undefined,
+  params: Parameters<T>,
+): boolean {
+  // Allow useErrorBoundary function to override throwing behavior on a per-error basis
+  if (typeof _useErrorBoundary === 'function') {
+    return _useErrorBoundary(...params)
+  }
+
+  return !!_useErrorBoundary
+}
+
+export function sleep(timeout: number): Promise<void> {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeout)
+  })
+}
+
+/**
+ * Schedules a microtask.
+ * This can be useful to schedule state updates after rendering.
+ */
+export function scheduleMicrotask(callback: () => void) {
+  sleep(0).then(callback)
+}