@better-auth-ui/react 1.6.8 → 1.6.9

package/src/mutations/settings/revoke-session-mutation.ts

@@ -1,9 +1,13 @@
-import { authMutationKeys } from "@better-auth-ui/core"
-import { mutationOptions, useMutation } from "@tanstack/react-query"
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core"
+import {
+  mutationOptions,
+  type QueryClient,
+  useMutation
+} from "@tanstack/react-query"
 import type { BetterFetchError } from "better-auth/react"
 
 import type { AuthClient } from "../../lib/auth-client"
-import { useListSessions } from "../../queries/settings/list-sessions-query"
+import { useSession } from "../../queries/auth/session-query"
 
 export type RevokeSessionParams<TAuthClient extends AuthClient> = Parameters<
   TAuthClient["revokeSession"]
@@ -11,7 +15,7 @@ export type RevokeSessionParams<TAuthClient extends AuthClient> = Parameters<
 
 export type RevokeSessionOptions<TAuthClient extends AuthClient> = Omit<
   ReturnType<typeof revokeSessionOptions<TAuthClient>>,
-  "mutationKey" | "mutationFn"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -43,27 +47,28 @@ export function revokeSessionOptions<TAuthClient extends AuthClient>(
 /**
  * Create a mutation for revoking a user session.
  *
- * Wraps `authClient.revokeSession`, refetches the sessions list on success,
- * and forwards React Query mutation options such as `onSuccess`, `onError`,
- * and `retry`.
+ * On success, `MutationInvalidator` awaits invalidation of the sessions
+ * list (see `meta.awaits`).
  *
  * @param authClient - The Better Auth client.
  * @param options - React Query options forwarded to `useMutation`.
  */
 export function useRevokeSession<TAuthClient extends AuthClient>(
   authClient: TAuthClient,
-  options?: RevokeSessionOptions<TAuthClient>
+  options?: RevokeSessionOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const { refetch: refetchSessions } = useListSessions(authClient, {
-    refetchOnMount: false
-  })
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
 
-  return useMutation({
-    ...revokeSessionOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      await refetchSessions()
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...revokeSessionOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [authQueryKeys.listSessions(userId)]
+      }
+    },
+    queryClient
+  )
 }

package/src/mutations/settings/unlink-account-mutation.ts

@@ -1,9 +1,13 @@
-import { authMutationKeys } from "@better-auth-ui/core"
-import { mutationOptions, useMutation } from "@tanstack/react-query"
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core"
+import {
+  mutationOptions,
+  type QueryClient,
+  useMutation
+} from "@tanstack/react-query"
 import type { BetterFetchError } from "better-auth/react"
 
 import type { AuthClient } from "../../lib/auth-client"
-import { useListAccounts } from "../../queries/settings/list-accounts-query"
+import { useSession } from "../../queries/auth/session-query"
 
 export type UnlinkAccountParams<TAuthClient extends AuthClient> = Parameters<
   TAuthClient["unlinkAccount"]
@@ -11,7 +15,7 @@ export type UnlinkAccountParams<TAuthClient extends AuthClient> = Parameters<
 
 export type UnlinkAccountOptions<TAuthClient extends AuthClient> = Omit<
   ReturnType<typeof unlinkAccountOptions<TAuthClient>>,
-  "mutationKey" | "mutationFn"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -43,25 +47,28 @@ export function unlinkAccountOptions<TAuthClient extends AuthClient>(
 /**
  * Create a mutation for unlinking a social provider from the current user.
  *
- * Wraps `authClient.unlinkAccount`, refetches the linked accounts list on
- * success, and forwards React Query mutation options such as `onSuccess`,
- * `onError`, and `retry`.
+ * On success, `MutationInvalidator` awaits invalidation of the linked
+ * accounts list (see `meta.awaits`).
  *
  * @param authClient - The Better Auth client.
  * @param options - React Query options forwarded to `useMutation`.
  */
 export function useUnlinkAccount<TAuthClient extends AuthClient>(
   authClient: TAuthClient,
-  options?: UnlinkAccountOptions<TAuthClient>
+  options?: UnlinkAccountOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const { refetch } = useListAccounts(authClient, { refetchOnMount: false })
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
 
-  return useMutation({
-    ...unlinkAccountOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      await refetch()
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...unlinkAccountOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [authQueryKeys.listAccounts(userId)]
+      }
+    },
+    queryClient
+  )
 }

package/src/mutations/settings/update-user-mutation.ts

@@ -1,12 +1,12 @@
-import { authMutationKeys } from "@better-auth-ui/core"
+import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core"
 import {
   mutationOptions,
-  useMutation,
-  useQueryClient
+  type QueryClient,
+  useMutation
 } from "@tanstack/react-query"
 import type { BetterFetchError } from "better-auth/react"
+
 import type { AuthClient } from "../../lib/auth-client"
-import { sessionOptions, useSession } from "../../queries/auth/session-query"
 
 export type UpdateUserParams<TAuthClient extends AuthClient> = Parameters<
   TAuthClient["updateUser"]
@@ -14,7 +14,7 @@ export type UpdateUserParams<TAuthClient extends AuthClient> = Parameters<
 
 export type UpdateUserOptions<TAuthClient extends AuthClient> = Omit<
   ReturnType<typeof updateUserOptions<TAuthClient>>,
-  "mutationKey" | "mutationFn"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -46,37 +46,25 @@ export function updateUserOptions<TAuthClient extends AuthClient>(
 /**
  * Create a mutation for updating the authenticated user's profile.
  *
- * Wraps `authClient.updateUser`, optimistically patches the cached session
- * with the new fields, refetches the session, and forwards React Query
- * mutation options such as `onSuccess`, `onError`, and `retry`.
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * query so the updated user fields are reflected (see `meta.awaits`).
  *
  * @param authClient - The Better Auth client.
  * @param options - React Query options forwarded to `useMutation`.
  */
 export function useUpdateUser<TAuthClient extends AuthClient>(
   authClient: TAuthClient,
-  options?: UpdateUserOptions<TAuthClient>
+  options?: UpdateUserOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const { data: session, refetch: refetchSession } = useSession(authClient, {
-    refetchOnMount: false
-  })
-
-  const queryClient = useQueryClient()
-
-  return useMutation({
-    ...updateUserOptions(authClient),
-    ...options,
-    onSuccess: async (data, variables, ...rest) => {
-      if (session) {
-        queryClient.setQueryData(sessionOptions(authClient).queryKey, {
-          ...session,
-          user: { ...session.user, ...variables }
-        })
+  return useMutation(
+    {
+      ...updateUserOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [authQueryKeys.session]
       }
-
-      refetchSession()
-
-      await options?.onSuccess?.(data, variables, ...rest)
-    }
-  })
+    },
+    queryClient
+  )
 }

package/src/mutations/username/is-username-available-mutation.ts

@@ -1,4 +1,4 @@
-import { authMutationKeys } from "@better-auth-ui/core"
+import { usernameMutationKeys } from "@better-auth-ui/core/plugins"
 import { mutationOptions, useMutation } from "@tanstack/react-query"
 import type { BetterFetchError } from "better-auth/react"
 
@@ -24,7 +24,7 @@ export type IsUsernameAvailableOptions<TAuthClient extends UsernameAuthClient> =
 export function isUsernameAvailableOptions<
   TAuthClient extends UsernameAuthClient
 >(authClient: TAuthClient) {
-  const mutationKey = authMutationKeys.isUsernameAvailable
+  const mutationKey = usernameMutationKeys.isUsernameAvailable
 
   const mutationFn = (params: IsUsernameAvailableParams<TAuthClient>) =>
     authClient.isUsernameAvailable({

package/src/mutations/username/sign-in-username-mutation.ts

@@ -1,13 +1,13 @@
-import { authMutationKeys } from "@better-auth-ui/core"
+import { authQueryKeys } from "@better-auth-ui/core"
+import { usernameMutationKeys } from "@better-auth-ui/core/plugins"
 import {
   mutationOptions,
-  useMutation,
-  useQueryClient
+  type QueryClient,
+  useMutation
 } from "@tanstack/react-query"
 import type { BetterFetchError } from "better-auth/react"
 
 import type { UsernameAuthClient } from "../../lib/auth-client"
-import { sessionOptions } from "../../queries/auth/session-query"
 
 export type SignInUsernameParams<TAuthClient extends UsernameAuthClient> =
   Parameters<TAuthClient["signIn"]["username"]>[0]
@@ -15,7 +15,7 @@ export type SignInUsernameParams<TAuthClient extends UsernameAuthClient> =
 export type SignInUsernameOptions<TAuthClient extends UsernameAuthClient> =
   Omit<
     ReturnType<typeof signInUsernameOptions<TAuthClient>>,
-    "mutationKey" | "mutationFn"
+    "mutationKey" | "mutationFn" | "meta"
   >
 
 /**
@@ -26,7 +26,7 @@ export type SignInUsernameOptions<TAuthClient extends UsernameAuthClient> =
 export function signInUsernameOptions<TAuthClient extends UsernameAuthClient>(
   authClient: TAuthClient
 ) {
-  const mutationKey = authMutationKeys.signIn.username
+  const mutationKey = usernameMutationKeys.signIn
 
   const mutationFn = (params: SignInUsernameParams<TAuthClient>) =>
     authClient.signIn.username({
@@ -47,28 +47,25 @@ export function signInUsernameOptions<TAuthClient extends UsernameAuthClient>(
 /**
  * Create a mutation for username/password sign-in.
  *
- * Wraps `authClient.signIn.username`, resets the session query on success so
- * the new session is refetched, and forwards React Query mutation options
- * such as `onSuccess`, `onError`, and `retry`.
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * query so the new session is refetched (see `meta.awaits`).
  *
  * @param authClient - The Better Auth client with the username plugin.
  * @param options - React Query options forwarded to `useMutation`.
  */
 export function useSignInUsername<TAuthClient extends UsernameAuthClient>(
   authClient: TAuthClient,
-  options?: SignInUsernameOptions<TAuthClient>
+  options?: SignInUsernameOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const queryClient = useQueryClient()
-
-  return useMutation({
-    ...signInUsernameOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      queryClient.resetQueries({
-        queryKey: sessionOptions(authClient).queryKey
-      })
-
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...signInUsernameOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [authQueryKeys.session]
+      }
+    },
+    queryClient
+  )
 }

package/src/queries/api-key/list-api-keys-query.ts

@@ -1,4 +1,4 @@
-import { authQueryKeys } from "@better-auth-ui/core"
+import { apiKeyQueryKeys } from "@better-auth-ui/core/plugins"
 import {
   type DataTag,
   type QueryClient,
@@ -11,18 +11,21 @@ import type { BetterFetchError } from "better-auth/react"
 import type { ApiKeyAuthClient, InferData } from "../../lib/auth-client"
 import { useSession } from "../auth/session-query"
 
-export type ListApiKeysData<TAuthClient extends ApiKeyAuthClient> = InferData<
-  TAuthClient["apiKey"]["list"]
->
+export type ListApiKeysData<
+  TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient
+> = InferData<TAuthClient["apiKey"]["list"]>
 
-export type ListApiKeysParams<TAuthClient extends ApiKeyAuthClient> =
-  Parameters<TAuthClient["apiKey"]["list"]>[0]
+export type ListApiKeysParams<
+  TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient
+> = Parameters<TAuthClient["apiKey"]["list"]>[0]
 
 export type ListedApiKey<
   TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient
 > = NonNullable<ListApiKeysData<TAuthClient>>["apiKeys"][number]
 
-export type ListApiKeysOptions<TAuthClient extends ApiKeyAuthClient> = Omit<
+export type ListApiKeysOptions<
+  TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient
+> = Omit<
   ReturnType<typeof listApiKeysOptions<TAuthClient>>,
   "queryKey" | "queryFn"
 >
@@ -30,6 +33,10 @@ export type ListApiKeysOptions<TAuthClient extends ApiKeyAuthClient> = Omit<
 /**
  * Query options factory for the current user's API keys.
  *
+ * Shares a query key with the server-side `listApiKeysOptions` from
+ * `@better-auth-ui/react/server`, so SSR-hydrated data is reused from the
+ * cache without an immediate refetch.
+ *
  * @param authClient - The Better Auth client with the API key plugin.
  * @param userId - The current signed-in user's ID. Used for cache partitioning.
  * @param params - Parameters forwarded to `authClient.apiKey.list`.
@@ -40,7 +47,7 @@ export function listApiKeysOptions<TAuthClient extends ApiKeyAuthClient>(
   params?: ListApiKeysParams<TAuthClient>
 ) {
   type TData = ListApiKeysData<TAuthClient>
-  const queryKey = authQueryKeys.listApiKeys(userId, params?.query)
+  const queryKey = apiKeyQueryKeys.list(userId, params?.query)
 
   const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
     {
@@ -85,6 +92,11 @@ export type UseListApiKeysOptions<TAuthClient extends ApiKeyAuthClient> =
 /**
  * Subscribe to the current user's API keys via TanStack Query.
  *
+ * Shares a query key with the server-side `listApiKeysOptions`, so
+ * SSR-hydrated data is reused from the cache without an immediate refetch.
+ * The query is gated on a signed-in user; while the session is loading or
+ * absent, the underlying `queryFn` is replaced with `skipToken`.
+ *
  * @param authClient - The Better Auth client with the API key plugin.
  * @param options - `apiKey.list` params merged with `useQuery` options.
  * @param queryClient - Optional custom `QueryClient`.

package/src/queries/multi-session/list-device-sessions-query.ts

@@ -1,4 +1,4 @@
-import { authQueryKeys } from "@better-auth-ui/core"
+import { multiSessionQueryKeys } from "@better-auth-ui/core/plugins"
 import {
   type DataTag,
   type QueryClient,
@@ -45,7 +45,7 @@ export function listDeviceSessionsOptions<
   params?: ListDeviceSessionsParams<TAuthClient>
 ) {
   type TData = ListDeviceSessionsData<TAuthClient>
-  const queryKey = authQueryKeys.listDeviceSessions(userId, params?.query)
+  const queryKey = multiSessionQueryKeys.list(userId, params?.query)
 
   const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
     {

package/src/queries/organization/active-organization-query.ts

@@ -0,0 +1,140 @@
+import {
+  organizationPlugin,
+  organizationQueryKeys
+} from "@better-auth-ui/core/plugins"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+import { useAuthPlugin } from "../../hooks/use-auth-plugin"
+import type { OrganizationAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+import type { FullOrganizationParams } from "./full-organization-query"
+import type { ListOrganization } from "./list-organizations-query"
+
+// The active-organization cache holds a `ListOrganization`-shaped value even
+// though we fetch via `getFullOrganization`. The `members`/`invitations`
+// fields are intentionally discarded by the `as Promise<TData>` cast in
+// `queryFn` below so that `setActive`'s optimistic update — which can only
+// produce a list-shaped org — never corrupts a full-detail cache entry.
+// See `organizationQueryKeys.activeOrganization` for the rationale.
+export type ActiveOrganizationData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = ListOrganization<TAuthClient>
+
+export type ActiveOrganizationParams<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = FullOrganizationParams<TAuthClient>
+
+export type ActiveOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof activeOrganizationOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function activeOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ActiveOrganizationParams<TAuthClient>
+) {
+  type TData = ActiveOrganizationData<TAuthClient>
+  const queryKey = organizationQueryKeys.activeOrganization(
+    userId,
+    params?.query
+  )
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.organization.getFullOrganization({
+          ...params,
+          fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, BetterFetchError>
+  }
+}
+
+export const ensureActiveOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ActiveOrganizationParams<TAuthClient>
+) =>
+  queryClient.ensureQueryData(
+    activeOrganizationOptions(authClient, userId, params)
+  )
+
+export const prefetchActiveOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ActiveOrganizationParams<TAuthClient>
+) =>
+  queryClient.prefetchQuery(
+    activeOrganizationOptions(authClient, userId, params)
+  )
+
+export const fetchActiveOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ActiveOrganizationParams<TAuthClient>
+) =>
+  queryClient.fetchQuery(activeOrganizationOptions(authClient, userId, params))
+
+export type UseActiveOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+> = ActiveOrganizationOptions<TAuthClient> &
+  ActiveOrganizationParams<TAuthClient>
+
+export function useActiveOrganization<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseActiveOrganizationOptions<TAuthClient> = {},
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  const { slug } = useAuthPlugin(organizationPlugin)
+
+  const { query, fetchOptions, ...queryOptions } = options
+
+  const baseOptions = activeOrganizationOptions(authClient, userId, {
+    fetchOptions,
+    query: slug ? { organizationSlug: slug } : query
+  })
+
+  return useQuery(
+    {
+      ...queryOptions,
+      ...baseOptions,
+      queryFn:
+        slug === null
+          ? async () => null
+          : userId
+            ? baseOptions.queryFn
+            : skipToken
+    },
+    queryClient
+  )
+}

package/src/queries/organization/full-organization-query.ts

@@ -0,0 +1,113 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+
+export type FullOrganizationData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = InferData<TAuthClient["organization"]["getFullOrganization"]>
+
+export type FullOrganizationParams<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["getFullOrganization"]>[0]
+
+export type FullOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof fullOrganizationOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function fullOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: FullOrganizationParams<TAuthClient>
+) {
+  type TData = FullOrganizationData<TAuthClient>
+  const queryKey = organizationQueryKeys.fullDetail(userId, params?.query)
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.organization.getFullOrganization({
+          ...params,
+          fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, BetterFetchError>
+  }
+}
+
+export const ensureFullOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: FullOrganizationParams<TAuthClient>
+) =>
+  queryClient.ensureQueryData(
+    fullOrganizationOptions(authClient, userId, params)
+  )
+
+export const prefetchFullOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: FullOrganizationParams<TAuthClient>
+) =>
+  queryClient.prefetchQuery(fullOrganizationOptions(authClient, userId, params))
+
+export const fetchFullOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: FullOrganizationParams<TAuthClient>
+) => queryClient.fetchQuery(fullOrganizationOptions(authClient, userId, params))
+
+export type UseFullOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+> = FullOrganizationOptions<TAuthClient> & FullOrganizationParams<TAuthClient>
+
+export function useFullOrganization<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient,
+  options: UseFullOrganizationOptions<TAuthClient> = {},
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  const { query, fetchOptions, ...queryOptions } = options
+
+  const baseOptions = fullOrganizationOptions(authClient, userId, {
+    query,
+    fetchOptions
+  })
+
+  return useQuery(
+    {
+      ...queryOptions,
+      ...baseOptions,
+      queryFn: userId ? baseOptions.queryFn : skipToken
+    },
+    queryClient
+  )
+}