@better-auth-ui/react 1.6.3 → 1.6.4

package/src/queries/settings/list-sessions-query.ts

@@ -0,0 +1,154 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { AuthClient, InferData } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+
+export type ListSessionsData<TAuthClient extends AuthClient> = InferData<
+  TAuthClient["listSessions"]
+>
+
+export type ListSessionsParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["listSessions"]
+>[0]
+
+export type ListSession<TAuthClient extends AuthClient = AuthClient> =
+  NonNullable<ListSessionsData<TAuthClient>>[number]
+
+export type ListSessionsOptions<TAuthClient extends AuthClient> = Omit<
+  ReturnType<typeof listSessionsOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+/**
+ * Query options factory for the current user's active sessions.
+ *
+ * @param authClient - The Better Auth client.
+ * @param userId - The current signed-in user's ID. Used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listSessions`.
+ */
+export function listSessionsOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListSessionsParams<TAuthClient>
+) {
+  type TData = ListSessionsData<TAuthClient>
+  const queryKey = authQueryKeys.listSessions(userId, params?.query)
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.listSessions({
+          ...params,
+          fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, BetterFetchError>
+  }
+}
+
+/**
+ * Get the current user's active sessions from the query cache, calling
+ * `fetchListSessions` under the hood if no cached entry exists. Resolves
+ * with the session list, making it ideal for loaders or `beforeLoad` guards.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listSessions`.
+ */
+export const ensureListSessions = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListSessionsParams<TAuthClient>
+) =>
+  queryClient.ensureQueryData(listSessionsOptions(authClient, userId, params))
+
+/**
+ * Prefetch the current user's active sessions into the query cache. Behaves
+ * like `fetchListSessions`, but does not throw on error and does not return
+ * the data — use this to warm the cache without blocking navigation.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listSessions`.
+ */
+export const prefetchListSessions = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListSessionsParams<TAuthClient>
+) => queryClient.prefetchQuery(listSessionsOptions(authClient, userId, params))
+
+/**
+ * Fetch and cache the current user's active sessions, resolving with the
+ * data or throwing on error. If a cached entry exists and is neither
+ * invalidated nor older than `staleTime`, the cached value is returned
+ * without a network call; otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client.
+ * @param authClient - The Better Auth client.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `authClient.listSessions`.
+ */
+export const fetchListSessions = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListSessionsParams<TAuthClient>
+) => queryClient.fetchQuery(listSessionsOptions(authClient, userId, params))
+
+export type UseListSessionsOptions<TAuthClient extends AuthClient> =
+  ListSessionsOptions<TAuthClient> & ListSessionsParams<TAuthClient>
+
+/**
+ * Subscribe to the current user's active sessions via TanStack Query.
+ *
+ * Shares a query key with the server-side `listSessionsOptions`, 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.
+ * @param options - `listSessions` params (`query`, `fetchOptions`) merged
+ *   with `useQuery` options (e.g. `enabled`, `staleTime`, `select`).
+ * @param queryClient - Optional custom `QueryClient`. Defaults to the client
+ *   from the nearest `QueryClientProvider`.
+ */
+export function useListSessions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  options: UseListSessionsOptions<TAuthClient> = {},
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  const { query, fetchOptions, ...queryOptions } = options
+
+  const baseOptions = listSessionsOptions(authClient, userId, {
+    query,
+    fetchOptions
+  })
+
+  return useQuery(
+    {
+      ...queryOptions,
+      ...baseOptions,
+      queryFn: userId ? baseOptions.queryFn : skipToken
+    },
+    queryClient
+  )
+}

package/src/server/queries/auth/session-query.ts

@@ -0,0 +1,94 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions
+} from "@tanstack/react-query"
+import type { APIError } from "better-auth"
+
+import type { AuthServer } from "../../../lib/auth-server"
+
+export type SessionData<TAuth extends AuthServer = AuthServer> = Awaited<
+  ReturnType<TAuth["api"]["getSession"]>
+>
+
+export type Session<TAuth extends AuthServer = AuthServer> = NonNullable<
+  SessionData<TAuth>
+>
+
+export type SessionParams<TAuth extends AuthServer> = Parameters<
+  TAuth["api"]["getSession"]
+>[0]
+
+/**
+ * Query options factory for the current session on the server.
+ *
+ * Uses the same query key as the client-side `sessionOptions` so that data
+ * fetched during SSR hydrates seamlessly into the client's React Query cache.
+ *
+ * @param auth - The Better Auth server instance.
+ * @param params - Parameters forwarded to `auth.api.getSession` (typically
+ *   includes request `headers` for cookie-based session resolution).
+ */
+export function sessionOptions<TAuth extends AuthServer>(
+  auth: TAuth,
+  params: SessionParams<TAuth>
+) {
+  type TData = SessionData<TAuth>
+  const queryKey = authQueryKeys.session
+
+  const options = queryOptions<TData, APIError, TData, typeof queryKey>({
+    queryKey,
+    queryFn: () => auth.api.getSession(params) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, APIError>
+  }
+}
+
+/**
+ * Get the current session from the query cache, calling `fetchSession` under
+ * the hood if no cached entry exists. Resolves with the session data, making
+ * it suitable for reading the value directly in a server component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param params - Parameters forwarded to `auth.api.getSession`.
+ */
+export const ensureSession = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  params: SessionParams<TAuth>
+) => queryClient.ensureQueryData(sessionOptions(auth, params))
+
+/**
+ * Prefetch the current session into the query cache. Behaves like
+ * `fetchSession`, but does not throw on error and does not return the data —
+ * use this when you only need the value to be available after hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param params - Parameters forwarded to `auth.api.getSession`.
+ */
+export const prefetchSession = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  params: SessionParams<TAuth>
+) => queryClient.prefetchQuery(sessionOptions(auth, params))
+
+/**
+ * Fetch and cache the current session, resolving with the data or throwing
+ * on error. If a cached entry exists and is neither invalidated nor older
+ * than `staleTime`, the cached value is returned without a network call;
+ * otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param params - Parameters forwarded to `auth.api.getSession`.
+ */
+export const fetchSession = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  params: SessionParams<TAuth>
+) => queryClient.fetchQuery(sessionOptions(auth, params))

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

@@ -0,0 +1,102 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions
+} from "@tanstack/react-query"
+import type { APIError } from "better-auth"
+
+import type { MultiSessionAuthServer } from "../../../lib/auth-server"
+
+export type ListDeviceSessionsData<TAuth extends MultiSessionAuthServer> =
+  Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>
+
+export type ListDeviceSession<
+  TAuth extends MultiSessionAuthServer = MultiSessionAuthServer
+> = NonNullable<ListDeviceSessionsData<TAuth>>[number]
+
+export type ListDeviceSessionsParams<TAuth extends MultiSessionAuthServer> =
+  Parameters<TAuth["api"]["listDeviceSessions"]>[0]
+
+/**
+ * Query options factory for the current user's device sessions.
+ *
+ * @param auth - The Better Auth server instance with the multi-session plugin.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `listDeviceSessionsOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
+ */
+export function listDeviceSessionsOptions<TAuth extends MultiSessionAuthServer>(
+  auth: TAuth,
+  userId: string,
+  params: ListDeviceSessionsParams<TAuth>
+) {
+  type TData = ListDeviceSessionsData<TAuth>
+  const queryKey = authQueryKeys.listDeviceSessions(userId, params?.query)
+
+  const options = queryOptions<TData, APIError, TData, typeof queryKey>({
+    queryKey,
+    queryFn: () => auth.api.listDeviceSessions(params) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, APIError>
+  }
+}
+
+/**
+ * Get the current user's device sessions from the query cache, calling
+ * `fetchListDeviceSessions` under the hood if no cached entry exists.
+ * Resolves with the device session list, making it suitable for reading
+ * directly in a server component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the multi-session plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
+ */
+export const ensureListDeviceSessions = <TAuth extends MultiSessionAuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListDeviceSessionsParams<TAuth>
+) =>
+  queryClient.ensureQueryData(listDeviceSessionsOptions(auth, userId, params))
+
+/**
+ * Prefetch the current user's device sessions into the query cache. Behaves
+ * like `fetchListDeviceSessions`, but does not throw on error and does not
+ * return the data — use this when you only need the value to be available
+ * after hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the multi-session plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
+ */
+export const prefetchListDeviceSessions = <
+  TAuth extends MultiSessionAuthServer
+>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListDeviceSessionsParams<TAuth>
+) => queryClient.prefetchQuery(listDeviceSessionsOptions(auth, userId, params))
+
+/**
+ * Fetch and cache the current user's device sessions, resolving with the
+ * data or throwing on error. If a cached entry exists and is neither
+ * invalidated nor older than `staleTime`, the cached value is returned
+ * without a network call; otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the multi-session plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
+ */
+export const fetchListDeviceSessions = <TAuth extends MultiSessionAuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListDeviceSessionsParams<TAuth>
+) => queryClient.fetchQuery(listDeviceSessionsOptions(auth, userId, params))

package/src/server/queries/passkey/list-passkeys-query.ts

@@ -0,0 +1,100 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions
+} from "@tanstack/react-query"
+import type { APIError } from "better-auth"
+
+import type { PasskeyAuthServer } from "../../../lib/auth-server"
+
+export type ListPasskeysData<TAuth extends PasskeyAuthServer> = Awaited<
+  ReturnType<TAuth["api"]["listPasskeys"]>
+>
+
+export type ListPasskeysParams<TAuth extends PasskeyAuthServer> = Parameters<
+  TAuth["api"]["listPasskeys"]
+>[0]
+
+export type ListPasskey<TAuth extends PasskeyAuthServer = PasskeyAuthServer> =
+  NonNullable<ListPasskeysData<TAuth>>[number]
+
+/**
+ * Query options factory for the current user's passkeys.
+ *
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `listPasskeysOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export function listPasskeysOptions<TAuth extends PasskeyAuthServer>(
+  auth: TAuth,
+  userId: string,
+  params: ListPasskeysParams<TAuth>
+) {
+  type TData = ListPasskeysData<TAuth>
+  const queryKey = authQueryKeys.listPasskeys(userId, params?.query)
+
+  const options = queryOptions<TData, APIError, TData, typeof queryKey>({
+    queryKey,
+    queryFn: () => auth.api.listPasskeys(params) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, APIError>
+  }
+}
+
+/**
+ * Get the current user's passkeys from the query cache, calling
+ * `fetchListPasskeys` under the hood if no cached entry exists. Resolves
+ * with the passkey list, making it suitable for reading directly in a server
+ * component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export const ensureListPasskeys = <TAuth extends PasskeyAuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListPasskeysParams<TAuth>
+) => queryClient.ensureQueryData(listPasskeysOptions(auth, userId, params))
+
+/**
+ * Prefetch the current user's passkeys into the query cache. Behaves like
+ * `fetchListPasskeys`, but does not throw on error and does not return
+ * the data — use this when you only need the value to be available after
+ * hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export const prefetchListPasskeys = <TAuth extends PasskeyAuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListPasskeysParams<TAuth>
+) => queryClient.prefetchQuery(listPasskeysOptions(auth, userId, params))
+
+/**
+ * Fetch and cache the current user's passkeys, resolving with the data or
+ * throwing on error. If a cached entry exists and is neither invalidated
+ * nor older than `staleTime`, the cached value is returned without a
+ * network call; otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance with the passkey plugin.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listPasskeys`.
+ */
+export const fetchListPasskeys = <TAuth extends PasskeyAuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListPasskeysParams<TAuth>
+) => queryClient.fetchQuery(listPasskeysOptions(auth, userId, params))

package/src/server/queries/settings/account-info-query.ts

@@ -0,0 +1,101 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions
+} from "@tanstack/react-query"
+import type { APIError } from "better-auth"
+
+import type { AuthServer } from "../../../lib/auth-server"
+
+export type AccountInfoData<TAuth extends AuthServer = AuthServer> = Awaited<
+  ReturnType<TAuth["api"]["accountInfo"]>
+>
+
+export type AccountInfoParams<TAuth extends AuthServer> = Parameters<
+  TAuth["api"]["accountInfo"]
+>[0]
+
+export type AccountInfo<TAuth extends AuthServer = AuthServer> = NonNullable<
+  AccountInfoData<TAuth>
+>
+
+/**
+ * Query options factory for provider-specific account info.
+ *
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `accountInfoOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export function accountInfoOptions<TAuth extends AuthServer>(
+  auth: TAuth,
+  userId: string,
+  params: AccountInfoParams<TAuth>
+) {
+  type TData = AccountInfoData<TAuth>
+  const queryKey = authQueryKeys.accountInfo(userId, params?.query)
+
+  const options = queryOptions<TData, APIError, TData, typeof queryKey>({
+    queryKey,
+    queryFn: () => auth.api.accountInfo(params) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, APIError>
+  }
+}
+
+/**
+ * Get the current user's provider-specific account info from the query
+ * cache, calling `fetchAccountInfo` under the hood if no cached entry
+ * exists. Resolves with the data, making it suitable for reading directly
+ * in a server component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export const ensureAccountInfo = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: AccountInfoParams<TAuth>
+) => queryClient.ensureQueryData(accountInfoOptions(auth, userId, params))
+
+/**
+ * Prefetch the current user's provider-specific account info into the query
+ * cache. Behaves like `fetchAccountInfo`, but does not throw on error and
+ * does not return the data — use this when you only need the value to be
+ * available after hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export const prefetchAccountInfo = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: AccountInfoParams<TAuth>
+) => queryClient.prefetchQuery(accountInfoOptions(auth, userId, params))
+
+/**
+ * Fetch and cache the current user's provider-specific account info,
+ * resolving with the data or throwing on error. If a cached entry exists
+ * and is neither invalidated nor older than `staleTime`, the cached value
+ * is returned without a network call; otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.accountInfo`.
+ */
+export const fetchAccountInfo = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: AccountInfoParams<TAuth>
+) => queryClient.fetchQuery(accountInfoOptions(auth, userId, params))

package/src/server/queries/settings/list-accounts-query.ts

@@ -0,0 +1,101 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions
+} from "@tanstack/react-query"
+import type { APIError } from "better-auth"
+
+import type { AuthServer } from "../../../lib/auth-server"
+
+export type ListAccountsData<TAuth extends AuthServer = AuthServer> = Awaited<
+  ReturnType<TAuth["api"]["listUserAccounts"]>
+>
+
+export type ListAccountsParams<TAuth extends AuthServer> = Parameters<
+  TAuth["api"]["listUserAccounts"]
+>[0]
+
+export type ListAccount<TAuth extends AuthServer = AuthServer> = NonNullable<
+  ListAccountsData<TAuth>
+>[number]
+
+/**
+ * Query options factory for the current user's linked social accounts.
+ *
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID. Used for cache partitioning so
+ *   the key matches the client-side `listAccountsOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export function listAccountsOptions<TAuth extends AuthServer>(
+  auth: TAuth,
+  userId: string,
+  params: ListAccountsParams<TAuth>
+) {
+  type TData = ListAccountsData<TAuth>
+  const queryKey = authQueryKeys.listAccounts(userId, params?.query)
+
+  const options = queryOptions<TData, APIError, TData, typeof queryKey>({
+    queryKey,
+    queryFn: () => auth.api.listUserAccounts(params) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, APIError>
+  }
+}
+
+/**
+ * Get the current user's linked social accounts from the query cache,
+ * calling `fetchListAccounts` under the hood if no cached entry exists.
+ * Resolves with the account list, making it suitable for reading directly
+ * in a server component.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export const ensureListAccounts = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListAccountsParams<TAuth>
+) => queryClient.ensureQueryData(listAccountsOptions(auth, userId, params))
+
+/**
+ * Prefetch the current user's linked social accounts into the query cache.
+ * Behaves like `fetchListAccounts`, but does not throw on error and does
+ * not return the data — use this when you only need the value to be
+ * available after hydration.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export const prefetchListAccounts = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListAccountsParams<TAuth>
+) => queryClient.prefetchQuery(listAccountsOptions(auth, userId, params))
+
+/**
+ * Fetch and cache the current user's linked social accounts, resolving
+ * with the data or throwing on error. If a cached entry exists and is
+ * neither invalidated nor older than `staleTime`, the cached value is
+ * returned without a network call; otherwise the latest data is fetched.
+ *
+ * @param queryClient - The React Query client used for SSR hydration.
+ * @param auth - The Better Auth server instance.
+ * @param userId - The signed-in user's ID, used for cache partitioning.
+ * @param params - Parameters forwarded to `auth.api.listUserAccounts`.
+ */
+export const fetchListAccounts = <TAuth extends AuthServer>(
+  queryClient: QueryClient,
+  auth: TAuth,
+  userId: string,
+  params: ListAccountsParams<TAuth>
+) => queryClient.fetchQuery(listAccountsOptions(auth, userId, params))