@effector-tanstack-query/core 0.1.0

package/src/createInfiniteQuery.ts

@@ -0,0 +1,291 @@
+import { attach, createEvent, createStore, sample, scopeBind } from 'effector'
+import { InfiniteQueryObserver } from '@tanstack/query-core'
+import type {
+  InfiniteData,
+  QueryClient,
+  QueryKey,
+} from '@tanstack/query-core'
+import { createBaseQuery, sidConfig, warnMissingName } from './createBaseQuery'
+import { resolveReactiveRefetchInterval } from './resolve'
+import type {
+  CreateInfiniteQueryOptions,
+  InfiniteQueryResult,
+} from './types'
+
+type Observer<TQueryFnData, TError, TData, TPageParam> = InfiniteQueryObserver<
+  TQueryFnData,
+  TError,
+  TData,
+  QueryKey,
+  TPageParam
+>
+
+type ObserverResult<TQueryFnData, TError, TData, TPageParam> = ReturnType<
+  Observer<TQueryFnData, TError, TData, TPageParam>['getCurrentResult']
+>
+
+export function createInfiniteQuery<
+  TQueryFnData = unknown,
+  TError = Error,
+  TPageParam = unknown,
+  TData = InfiniteData<TQueryFnData, TPageParam>,
+>(
+  options: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+): InfiniteQueryResult<TData, TError, TPageParam>
+export function createInfiniteQuery<
+  TQueryFnData = unknown,
+  TError = Error,
+  TPageParam = unknown,
+  TData = InfiniteData<TQueryFnData, TPageParam>,
+>(
+  queryClient: QueryClient,
+  options: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+): InfiniteQueryResult<TData, TError, TPageParam>
+export function createInfiniteQuery<
+  TQueryFnData = unknown,
+  TError = Error,
+  TPageParam = unknown,
+  TData = InfiniteData<TQueryFnData, TPageParam>,
+>(
+  arg1:
+    | QueryClient
+    | CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+  arg2?: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+): InfiniteQueryResult<TData, TError, TPageParam> {
+  const [explicitClient, options] = parseInfiniteArgs<
+    TQueryFnData,
+    TError,
+    TPageParam,
+    TData
+  >(arg1, arg2)
+  const { queryKey, enabled, name, ...restOptions } = options
+
+  if (!name) warnMissingName('createInfiniteQuery')
+
+  const reactiveRefetchInterval = resolveReactiveRefetchInterval(
+    (restOptions as { refetchInterval?: unknown }).refetchInterval,
+  )
+  if (reactiveRefetchInterval) {
+    delete (restOptions as { refetchInterval?: unknown }).refetchInterval
+  }
+
+  const base = createBaseQuery<
+    TData,
+    TError,
+    ObserverResult<TQueryFnData, TError, TData, TPageParam>,
+    Observer<TQueryFnData, TError, TData, TPageParam>,
+    {
+      $hasNextPage: ReturnType<typeof createStore<boolean>>
+      $hasPreviousPage: ReturnType<typeof createStore<boolean>>
+      $isFetchingNextPage: ReturnType<typeof createStore<boolean>>
+      $isFetchingPreviousPage: ReturnType<typeof createStore<boolean>>
+      $isFetchNextPageError: ReturnType<typeof createStore<boolean>>
+      $isFetchPreviousPageError: ReturnType<typeof createStore<boolean>>
+      fetchNextPage: ReturnType<typeof createEvent<void>>
+      fetchPreviousPage: ReturnType<typeof createEvent<void>>
+    }
+  >(
+    explicitClient,
+    { queryKey, enabled, name, reactiveRefetchInterval },
+    {
+      createObserver: (qc, { queryKey: key, enabled: isEnabled }) =>
+        new InfiniteQueryObserver<
+          TQueryFnData,
+          TError,
+          TData,
+          QueryKey,
+          TPageParam
+        >(qc, {
+          ...restOptions,
+          queryKey: key,
+          enabled: isEnabled,
+        } as any),
+      setupExtras: () => {
+        const hasNextPageUpdated = createEvent<boolean>()
+        const hasPreviousPageUpdated = createEvent<boolean>()
+        const isFetchingNextPageUpdated = createEvent<boolean>()
+        const isFetchingPreviousPageUpdated = createEvent<boolean>()
+        const isFetchNextPageErrorUpdated = createEvent<boolean>()
+        const isFetchPreviousPageErrorUpdated = createEvent<boolean>()
+
+        const $hasNextPage = createStore(false, {
+          ...sidConfig(name, '$hasNextPage'),
+        }).on(hasNextPageUpdated, (_, v) => v)
+        const $hasPreviousPage = createStore(false, {
+          ...sidConfig(name, '$hasPreviousPage'),
+        }).on(hasPreviousPageUpdated, (_, v) => v)
+        const $isFetchingNextPage = createStore(false, {
+          ...sidConfig(name, '$isFetchingNextPage'),
+        }).on(isFetchingNextPageUpdated, (_, v) => v)
+        const $isFetchingPreviousPage = createStore(false, {
+          ...sidConfig(name, '$isFetchingPreviousPage'),
+        }).on(isFetchingPreviousPageUpdated, (_, v) => v)
+        const $isFetchNextPageError = createStore(false, {
+          ...sidConfig(name, '$isFetchNextPageError'),
+        }).on(isFetchNextPageErrorUpdated, (_, v) => v)
+        const $isFetchPreviousPageError = createStore(false, {
+          ...sidConfig(name, '$isFetchPreviousPageError'),
+        }).on(isFetchPreviousPageErrorUpdated, (_, v) => v)
+
+        const fetchNextPage = createEvent<void>()
+        const fetchPreviousPage = createEvent<void>()
+
+        return {
+          stores: {
+            $hasNextPage,
+            $hasPreviousPage,
+            $isFetchingNextPage,
+            $isFetchingPreviousPage,
+            $isFetchNextPageError,
+            $isFetchPreviousPageError,
+            fetchNextPage,
+            fetchPreviousPage,
+          },
+          // Wire fetchNextPage / fetchPreviousPage as scope-aware effects via
+          // attach over $observer — same pattern as the rest of createBaseQuery.
+          setupEffects: ({ $observer }) => {
+            const fetchNextPageFx = attach({
+              source: $observer,
+              effect: (observer) => {
+                if (!observer) return
+                observer.fetchNextPage()
+              },
+            })
+            sample({ clock: fetchNextPage, target: fetchNextPageFx })
+
+            const fetchPreviousPageFx = attach({
+              source: $observer,
+              effect: (observer) => {
+                if (!observer) return
+                observer.fetchPreviousPage()
+              },
+            })
+            sample({ clock: fetchPreviousPage, target: fetchPreviousPageFx })
+          },
+          bindDispatcher: () => {
+            const dispatchHasNextPage = scopeBind(hasNextPageUpdated, {
+              safe: true,
+            })
+            const dispatchHasPreviousPage = scopeBind(hasPreviousPageUpdated, {
+              safe: true,
+            })
+            const dispatchIsFetchingNextPage = scopeBind(
+              isFetchingNextPageUpdated,
+              { safe: true },
+            )
+            const dispatchIsFetchingPreviousPage = scopeBind(
+              isFetchingPreviousPageUpdated,
+              { safe: true },
+            )
+            const dispatchIsFetchNextPageError = scopeBind(
+              isFetchNextPageErrorUpdated,
+              { safe: true },
+            )
+            const dispatchIsFetchPreviousPageError = scopeBind(
+              isFetchPreviousPageErrorUpdated,
+              { safe: true },
+            )
+
+            return (result) => {
+              dispatchHasNextPage(result.hasNextPage)
+              dispatchHasPreviousPage(result.hasPreviousPage)
+              dispatchIsFetchingNextPage(result.isFetchingNextPage)
+              dispatchIsFetchingPreviousPage(result.isFetchingPreviousPage)
+              dispatchIsFetchNextPageError(result.isFetchNextPageError)
+              dispatchIsFetchPreviousPageError(result.isFetchPreviousPageError)
+            }
+          },
+        }
+      },
+    },
+  )
+
+  // See createQuery.prefetch — same contract, but uses fetchInfiniteQuery so
+  // the first page is fetched + cached on the server.
+  const prefetch = createEvent<void>()
+  const prefetchFx = attach({
+    source: {
+      qc: base.$queryClient,
+      key: base.$resolvedKey,
+      enabled: base.$enabled,
+    },
+    effect: ({ qc, key, enabled }) => {
+      if (!qc || !enabled) return
+      return qc.fetchInfiniteQuery({
+        ...restOptions,
+        queryKey: key,
+      } as any)
+    },
+  })
+  sample({ clock: prefetch, target: prefetchFx })
+
+  const result: InfiniteQueryResult<TData, TError, TPageParam> = {
+    $data: base.$data,
+    $error: base.$error,
+    $status: base.$status,
+    $isPending: base.$isPending,
+    $isFetching: base.$isFetching,
+    $isSuccess: base.$isSuccess,
+    $isError: base.$isError,
+    $isPlaceholderData: base.$isPlaceholderData,
+    $fetchStatus: base.$fetchStatus,
+    $hasNextPage: base.$hasNextPage,
+    $hasPreviousPage: base.$hasPreviousPage,
+    $isFetchingNextPage: base.$isFetchingNextPage,
+    $isFetchingPreviousPage: base.$isFetchingPreviousPage,
+    $isFetchNextPageError: base.$isFetchNextPageError,
+    $isFetchPreviousPageError: base.$isFetchPreviousPageError,
+    $observer: base.$observer,
+    $queryClient: base.$queryClient,
+    fetchNextPage: base.fetchNextPage,
+    fetchPreviousPage: base.fetchPreviousPage,
+    refresh: base.refresh,
+    prefetch,
+    mounted: base.mounted,
+    unmounted: base.unmounted,
+  }
+
+  Object.defineProperty(result, '__createObserver', {
+    enumerable: false,
+    value: (qc: QueryClient, init: { queryKey: any; enabled: boolean }) =>
+      new InfiniteQueryObserver<
+        TQueryFnData,
+        TError,
+        TData,
+        QueryKey,
+        TPageParam
+      >(qc, {
+        ...restOptions,
+        queryKey: init.queryKey,
+        enabled: init.enabled,
+      } as any),
+  })
+  Object.defineProperty(result, '__resolvedKey', {
+    enumerable: false,
+    value: base.$resolvedKey,
+  })
+  Object.defineProperty(result, '__enabled', {
+    enumerable: false,
+    value: base.$enabled,
+  })
+
+  return result
+}
+
+function parseInfiniteArgs<TQueryFnData, TError, TPageParam, TData>(
+  arg1:
+    | QueryClient
+    | CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+  arg2?: CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+): [
+  QueryClient | null,
+  CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+] {
+  if (arg2 !== undefined) {
+    return [arg1 as QueryClient, arg2]
+  }
+  return [
+    null,
+    arg1 as CreateInfiniteQueryOptions<TQueryFnData, TError, TPageParam, TData>,
+  ]
+}

package/src/createInvalidate.ts

@@ -0,0 +1,104 @@
+import { attach, createEvent, createStore, sample } from 'effector'
+import type { EventCallable, Store } from 'effector'
+import type {
+  InvalidateQueryFilters,
+  QueryClient,
+} from '@tanstack/query-core'
+import { $queryClient } from './queryClient'
+import { resolveKey } from './resolve'
+import type { EffectorQueryKey } from './types'
+
+export interface CreateInvalidateOptions {
+  /**
+   * Key (or key prefix) to invalidate. Supports the same reactive shape as
+   * `createQuery.queryKey` — drop a `Store` anywhere in the array and the
+   * invalidate event will resolve it on every call, so dynamic keys "just
+   * work".
+   */
+  queryKey: EffectorQueryKey
+  /**
+   * Forwarded to `queryClient.invalidateQueries({ exact })`. With `exact: true`
+   * only queries whose key *exactly* matches are invalidated; otherwise the
+   * key is treated as a prefix.
+   */
+  exact?: boolean
+  /**
+   * Forwarded to `queryClient.invalidateQueries({ refetchType })`. Controls
+   * which observers refetch immediately after invalidation. Defaults to
+   * `'active'` (TanStack Query's own default).
+   */
+  refetchType?: 'active' | 'inactive' | 'all' | 'none'
+  /**
+   * Forwarded to `queryClient.invalidateQueries({ type })`. Filters which
+   * queries match — `'active'`, `'inactive'`, `'all'`.
+   */
+  type?: 'active' | 'inactive' | 'all'
+}
+
+/**
+ * Builds an effector event that invalidates a query (or a key prefix) on the
+ * resolved `QueryClient`. Useful when you want to invalidate a query
+ * declaratively from a `sample` (e.g. on a mutation's `finished.success`)
+ * without writing a one-off `attach` every time.
+ *
+ * @example Static key
+ * const invalidateFavorites = createInvalidate({ queryKey: ['favorites'] })
+ * sample({ clock: addFavorite.finished.success, target: invalidateFavorites })
+ *
+ * @example Reactive key — uses current $userId at invocation time
+ * const invalidateUser = createInvalidate({ queryKey: ['user', $userId] })
+ *
+ * @example Explicit client (same back-compat overload as the other factories)
+ * const invalidateFavorites = createInvalidate(queryClient, { queryKey: ['favorites'] })
+ */
+export function createInvalidate(
+  options: CreateInvalidateOptions,
+): EventCallable<void>
+export function createInvalidate(
+  queryClient: QueryClient,
+  options: CreateInvalidateOptions,
+): EventCallable<void>
+export function createInvalidate(
+  arg1: QueryClient | CreateInvalidateOptions,
+  arg2?: CreateInvalidateOptions,
+): EventCallable<void> {
+  const [explicitClient, options] = parseArgs(arg1, arg2)
+  const { queryKey, exact, refetchType, type } = options
+
+  // Same locking semantics as the other factories: explicit client freezes
+  // the store, default flows through global $queryClient (and respects
+  // fork({ values: [[$queryClient, qc]] }) for per-scope isolation).
+  const $effectiveClient: Store<QueryClient | null> = explicitClient
+    ? createStore(explicitClient as QueryClient | null, {
+        serialize: 'ignore',
+      })
+    : $queryClient
+
+  const $resolvedKey = resolveKey(queryKey)
+
+  const invalidate = createEvent<void>()
+
+  const invalidateFx = attach({
+    source: { qc: $effectiveClient, key: $resolvedKey },
+    effect: ({ qc, key }) => {
+      if (!qc) return
+      const filters: InvalidateQueryFilters = { queryKey: key }
+      if (exact !== undefined) filters.exact = exact
+      if (refetchType !== undefined) filters.refetchType = refetchType
+      if (type !== undefined) filters.type = type
+      return qc.invalidateQueries(filters)
+    },
+  })
+
+  sample({ clock: invalidate, target: invalidateFx })
+
+  return invalidate
+}
+
+function parseArgs(
+  arg1: QueryClient | CreateInvalidateOptions,
+  arg2?: CreateInvalidateOptions,
+): [QueryClient | null, CreateInvalidateOptions] {
+  if (arg2 !== undefined) return [arg1 as QueryClient, arg2]
+  return [null, arg1 as CreateInvalidateOptions]
+}

package/src/createMutation.ts

@@ -0,0 +1,271 @@
+import {
+  attach,
+  createEvent,
+  createStore,
+  sample,
+  scopeBind,
+} from 'effector'
+import type { Store } from 'effector'
+import { MutationObserver } from '@tanstack/query-core'
+import type { MutateOptions, QueryClient } from '@tanstack/query-core'
+import { $queryClient } from './queryClient'
+import { sidConfig, warnMissingName } from './createBaseQuery'
+import type { CreateMutationOptions, MutationResult } from './types'
+
+type MutationStatus = 'idle' | 'pending' | 'success' | 'error'
+
+export function createMutation<
+  TData = unknown,
+  TError = Error,
+  TVariables = void,
+  TOnMutateResult = unknown,
+>(
+  arg1:
+    | QueryClient
+    | CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+  arg2?: CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+): MutationResult<TData, TError, TVariables> {
+  const [explicitClient, options] = parseMutationArgs<
+    TData,
+    TError,
+    TVariables,
+    TOnMutateResult
+  >(arg1, arg2)
+
+  const { name, ...observerOptions } = options
+
+  if (!name) warnMissingName('createMutation')
+
+  const $effectiveClient: Store<QueryClient | null> = explicitClient
+    ? createStore(explicitClient as QueryClient | null, {
+        serialize: 'ignore',
+      })
+    : $queryClient
+
+  const dataUpdated = createEvent<TData | undefined>()
+  const errorUpdated = createEvent<TError | null>()
+  const statusUpdated = createEvent<MutationStatus>()
+  const variablesUpdated = createEvent<TVariables | undefined>()
+  const isPausedUpdated = createEvent<boolean>()
+  const finishedSuccess = createEvent<{ params: TVariables; result: TData }>()
+  const finishedFailure = createEvent<{ params: TVariables; error: TError }>()
+
+  const $data = createStore<TData | undefined>(undefined, {
+    skipVoid: false,
+    ...sidConfig(name, '$data'),
+  }).on(dataUpdated, (_, v) => v)
+  const $error = createStore<TError | null>(null, {
+    skipVoid: false,
+    ...sidConfig(name, '$error'),
+  }).on(errorUpdated, (_, v) => v)
+  const $status = createStore<MutationStatus>('idle', {
+    ...sidConfig(name, '$status'),
+  }).on(statusUpdated, (_, v) => v)
+  const $variables = createStore<TVariables | undefined>(undefined, {
+    skipVoid: false,
+    ...sidConfig(name, '$variables'),
+  }).on(variablesUpdated, (_, v) => v)
+  const $isPaused = createStore(false, {
+    ...sidConfig(name, '$isPaused'),
+  }).on(isPausedUpdated, (_, v) => v)
+
+  // Derived stores via .map don't take sid — they recompute from $status on
+  // the client after fork({ values }).
+  const $isPending = $status.map((s) => s === 'pending')
+  const $isSuccess = $status.map((s) => s === 'success')
+  const $isError = $status.map((s) => s === 'error')
+  const $isIdle = $status.map((s) => s === 'idle')
+
+  // Per-scope observer — same pattern as createBaseQuery. Each fork scope
+  // gets its own MutationObserver bound to its scope's QueryClient.
+  type Observer = MutationObserver<TData, TError, TVariables, TOnMutateResult>
+  const $observer = createStore<Observer | null>(null, {
+    serialize: 'ignore',
+  })
+  const observerCreated = createEvent<Observer>()
+  $observer.on(observerCreated, (_, obs) => obs)
+
+  const observerSubscriptions = new WeakMap<Observer, () => void>()
+
+  const start = createEvent<void>()
+  const unmounted = createEvent<void>()
+
+  const startFx = attach({
+    source: { qc: $effectiveClient, observer: $observer },
+    effect: ({ qc, observer: existingObserver }) => {
+      if (!qc) {
+        throw new Error(
+          '[@tanstack/query-effector] No QueryClient is set for createMutation. Call setQueryClient(qc) before start, ' +
+            'pass it to fork({ values: [[$queryClient, qc]] }), or pass it explicitly to the factory.',
+        )
+      }
+
+      const observer =
+        existingObserver ??
+        new MutationObserver<TData, TError, TVariables, TOnMutateResult>(
+          qc,
+          observerOptions,
+        )
+
+      const dispatchData = scopeBind(dataUpdated, { safe: true })
+      const dispatchError = scopeBind(errorUpdated, { safe: true })
+      const dispatchStatus = scopeBind(statusUpdated, { safe: true })
+      const dispatchVariables = scopeBind(variablesUpdated, { safe: true })
+      const dispatchIsPaused = scopeBind(isPausedUpdated, { safe: true })
+      const dispatchFinishedSuccess = scopeBind(finishedSuccess, { safe: true })
+      const dispatchFinishedFailure = scopeBind(finishedFailure, { safe: true })
+
+      observerSubscriptions.get(observer)?.()
+
+      // Track status transitions to emit `finished.success` / `finished.failure`
+      // exactly once per pending → terminal transition. The observer holds at
+      // most one inflight mutation at a time, so a single previous-status flag
+      // is sufficient.
+      let prevStatus: MutationStatus = 'idle'
+
+      const unsubscribe = observer.subscribe((result) => {
+        dispatchData(result.data)
+        dispatchError(result.error)
+        dispatchStatus(result.status)
+        dispatchVariables(result.variables)
+        dispatchIsPaused(result.isPaused)
+
+        if (prevStatus === 'pending') {
+          if (result.status === 'success') {
+            dispatchFinishedSuccess({
+              params: result.variables as TVariables,
+              result: result.data as TData,
+            })
+          } else if (result.status === 'error') {
+            dispatchFinishedFailure({
+              params: result.variables as TVariables,
+              error: result.error as TError,
+            })
+          }
+        }
+        prevStatus = result.status
+      })
+
+      observerSubscriptions.set(observer, unsubscribe)
+
+      return observer
+    },
+  })
+
+  sample({ clock: start, target: startFx })
+  sample({ clock: startFx.doneData, target: observerCreated })
+
+  // Mutation observers (unlike query observers) live across mount cycles —
+  // their data state survives unmount and can be observed again on re-start.
+  // Match that by keeping `$observer` populated; we only drop the
+  // subscription so listeners stop receiving updates after unmount.
+  const unmountFx = attach({
+    source: $observer,
+    effect: (observer) => {
+      if (!observer) return
+      observerSubscriptions.get(observer)?.()
+      observerSubscriptions.delete(observer)
+    },
+  })
+  sample({ clock: unmounted, target: unmountFx })
+
+  const mutate = createEvent<TVariables>()
+
+  // Fire-and-forget: don't return the promise so allSettled doesn't block
+  // (would deadlock under fake timers since observer.mutate awaits the user's
+  // mutationFn). Errors are tracked via the observer subscription which
+  // updates $error/$status and emits `finished.failure`.
+  const mutateFx = attach({
+    source: $observer,
+    effect: (observer, variables: TVariables) => {
+      if (!observer) return
+      observer.mutate(variables).catch(() => {})
+    },
+  })
+
+  sample({ clock: mutate, target: mutateFx })
+
+  // Per-call callbacks variant: forwards onSuccess/onError/onSettled to
+  // observer.mutate(vars, opts). Use this for component-local reactions
+  // that don't fit module-level `sample({ clock: finished.success })` wiring.
+  const mutateWith = createEvent<{
+    variables: TVariables
+    onSuccess?: MutateOptions<TData, TError, TVariables>['onSuccess']
+    onError?: MutateOptions<TData, TError, TVariables>['onError']
+    onSettled?: MutateOptions<TData, TError, TVariables>['onSettled']
+  }>()
+
+  const mutateWithFx = attach({
+    source: $observer,
+    effect: (
+      observer,
+      {
+        variables,
+        ...callbacks
+      }: {
+        variables: TVariables
+        onSuccess?: MutateOptions<TData, TError, TVariables>['onSuccess']
+        onError?: MutateOptions<TData, TError, TVariables>['onError']
+        onSettled?: MutateOptions<TData, TError, TVariables>['onSettled']
+      },
+    ) => {
+      if (!observer) return
+      observer.mutate(variables, callbacks).catch(() => {})
+    },
+  })
+
+  sample({ clock: mutateWith, target: mutateWithFx })
+
+  const reset = createEvent<void>()
+
+  const resetFx = attach({
+    source: $observer,
+    effect: (observer) => {
+      if (!observer) return
+      observer.reset()
+    },
+  })
+
+  sample({ clock: reset, target: resetFx })
+
+  return {
+    $data,
+    $error,
+    $status,
+    $variables,
+    $isPaused,
+    $isPending,
+    $isSuccess,
+    $isError,
+    $isIdle,
+    $observer,
+    $queryClient: $effectiveClient,
+    mutate,
+    mutateWith,
+    reset,
+    start,
+    unmounted,
+    finished: {
+      success: finishedSuccess,
+      failure: finishedFailure,
+    },
+  }
+}
+
+function parseMutationArgs<TData, TError, TVariables, TOnMutateResult>(
+  arg1:
+    | QueryClient
+    | CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+  arg2?: CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+): [
+  QueryClient | null,
+  CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+] {
+  if (arg2 !== undefined) {
+    return [arg1 as QueryClient, arg2]
+  }
+  return [
+    null,
+    arg1 as CreateMutationOptions<TData, TError, TVariables, TOnMutateResult>,
+  ]
+}