@better-auth-ui/react 1.6.3 → 1.6.4

package/src/mutations/magic-link/sign-in-magic-link-mutation.ts

@@ -0,0 +1,59 @@
+import { magicLinkMutationKeys } from "@better-auth-ui/core/plugins"
+import { mutationOptions, useMutation } from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { MagicLinkAuthClient } from "../../lib/auth-client"
+
+export type SignInMagicLinkParams<TAuthClient extends MagicLinkAuthClient> =
+  Parameters<TAuthClient["signIn"]["magicLink"]>[0]
+
+export type SignInMagicLinkOptions<TAuthClient extends MagicLinkAuthClient> =
+  Omit<
+    ReturnType<typeof signInMagicLinkOptions<TAuthClient>>,
+    "mutationKey" | "mutationFn"
+  >
+
+/**
+ * Mutation options factory for magic-link sign-in.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function signInMagicLinkOptions<TAuthClient extends MagicLinkAuthClient>(
+  authClient: TAuthClient
+) {
+  const mutationKey = magicLinkMutationKeys.signIn
+
+  const mutationFn = (params: SignInMagicLinkParams<TAuthClient>) =>
+    authClient.signIn.magicLink({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+/**
+ * Create a mutation for requesting a magic-link sign-in email.
+ *
+ * Wraps `authClient.signIn.magicLink` and forwards React Query mutation
+ * options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the magic-link plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useSignInMagicLink<TAuthClient extends MagicLinkAuthClient>(
+  authClient: TAuthClient,
+  options?: SignInMagicLinkOptions<TAuthClient>
+) {
+  return useMutation({
+    ...signInMagicLinkOptions(authClient),
+    ...options
+  })
+}

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

@@ -0,0 +1,70 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import { mutationOptions, useMutation } from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { MultiSessionAuthClient } from "../../lib/auth-client"
+import { useListDeviceSessions } from "../../queries/multi-session/list-device-sessions-query"
+
+export type RevokeMultiSessionParams<
+  TAuthClient extends MultiSessionAuthClient
+> = Parameters<TAuthClient["multiSession"]["revoke"]>[0]
+
+export type RevokeMultiSessionOptions<
+  TAuthClient extends MultiSessionAuthClient
+> = Omit<
+  ReturnType<typeof revokeMultiSessionOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn"
+>
+
+/**
+ * Mutation options factory for revoking a device session in multi-session mode.
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ */
+export function revokeMultiSessionOptions<
+  TAuthClient extends MultiSessionAuthClient
+>(authClient: TAuthClient) {
+  const mutationKey = authMutationKeys.multiSession.revoke
+
+  const mutationFn = (params: RevokeMultiSessionParams<TAuthClient>) =>
+    authClient.multiSession.revoke({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+/**
+ * Create a mutation for revoking a device session in multi-session mode.
+ *
+ * Wraps `authClient.multiSession.revoke`, refetches the device sessions list
+ * on success, and forwards React Query mutation options such as `onSuccess`,
+ * `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useRevokeMultiSession<
+  TAuthClient extends MultiSessionAuthClient
+>(authClient: TAuthClient, options?: RevokeMultiSessionOptions<TAuthClient>) {
+  const { refetch } = useListDeviceSessions(authClient, {
+    refetchOnMount: false
+  })
+
+  return useMutation({
+    ...revokeMultiSessionOptions(authClient),
+    ...options,
+    onSuccess: async (...args) => {
+      await refetch()
+      await options?.onSuccess?.(...args)
+    }
+  })
+}

package/src/mutations/multi-session/set-active-session-mutation.ts

@@ -0,0 +1,98 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import {
+  mutationOptions,
+  useMutation,
+  useQueryClient
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { MultiSessionAuthClient } from "../../lib/auth-client"
+import {
+  type SessionData,
+  sessionOptions,
+  useSession
+} from "../../queries/auth/session-query"
+import { useListDeviceSessions } from "../../queries/multi-session/list-device-sessions-query"
+
+export type SetActiveSessionParams<TAuthClient extends MultiSessionAuthClient> =
+  Parameters<TAuthClient["multiSession"]["setActive"]>[0]
+
+export type SetActiveSessionOptions<
+  TAuthClient extends MultiSessionAuthClient
+> = Omit<
+  ReturnType<typeof setActiveSessionOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn"
+>
+
+/**
+ * Mutation options factory for switching the active device session.
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ */
+export function setActiveSessionOptions<
+  TAuthClient extends MultiSessionAuthClient
+>(authClient: TAuthClient) {
+  const mutationKey = authMutationKeys.multiSession.setActive
+
+  const mutationFn = (params: SetActiveSessionParams<TAuthClient>) =>
+    authClient.multiSession.setActive({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+/**
+ * Create a mutation for switching the active device session.
+ *
+ * Wraps `authClient.multiSession.setActive`, optimistically swaps the cached
+ * session to the matching device session, refetches both the session and
+ * device-session queries, and forwards React Query mutation options such as
+ * `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the multi-session plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useSetActiveSession<TAuthClient extends MultiSessionAuthClient>(
+  authClient: TAuthClient,
+  options?: SetActiveSessionOptions<TAuthClient>
+) {
+  const queryClient = useQueryClient()
+  const { refetch: refetchSession } = useSession(authClient, {
+    refetchOnMount: false
+  })
+  const { data: deviceSessions, refetch: refetchDeviceSessions } =
+    useListDeviceSessions(authClient, {
+      refetchOnMount: false
+    })
+
+  return useMutation({
+    ...setActiveSessionOptions(authClient),
+    ...options,
+    onSuccess: async (data, variables, ...rest) => {
+      const sessionToken = variables?.sessionToken
+      const deviceSession = deviceSessions?.find(
+        ({ session: { token } }) => token === sessionToken
+      )
+
+      if (deviceSession) {
+        queryClient.setQueryData(
+          sessionOptions(authClient).queryKey,
+          deviceSession as SessionData<TAuthClient>
+        )
+      }
+
+      await refetchSession()
+      await refetchDeviceSessions()
+      await options?.onSuccess?.(data, variables, ...rest)
+    }
+  })
+}

package/src/mutations/passkey/add-passkey-mutation.ts

@@ -0,0 +1,66 @@
+import { passkeyMutationKeys } from "@better-auth-ui/core/plugins"
+import { mutationOptions, useMutation } from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+import type { PasskeyAuthClient } from "../../lib/auth-client"
+import { useListPasskeys } from "../../queries/passkey/list-passkeys-query"
+
+export type AddPasskeyParams<TAuthClient extends PasskeyAuthClient> =
+  Parameters<TAuthClient["passkey"]["addPasskey"]>[0]
+
+export type AddPasskeyOptions<TAuthClient extends PasskeyAuthClient> = Omit<
+  ReturnType<typeof addPasskeyOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn"
+>
+
+/**
+ * Mutation options factory for registering a new passkey.
+ *
+ * @param authClient - The Better Auth client with the passkey plugin.
+ */
+export function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient
+) {
+  const mutationKey = passkeyMutationKeys.addPasskey
+
+  // biome-ignore lint/suspicious/noConfusingVoidType: void allows no-arg mutate
+  const mutationFn = (params?: AddPasskeyParams<TAuthClient> | void) =>
+    authClient.passkey.addPasskey({
+      ...(params ?? {}),
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+/**
+ * Create a mutation for registering a new passkey.
+ *
+ * Wraps `authClient.passkey.addPasskey`, refetches the user's passkey list
+ * on success, and forwards React Query mutation options such as
+ * `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the passkey plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useAddPasskey<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient,
+  options?: AddPasskeyOptions<TAuthClient>
+) {
+  const { refetch } = useListPasskeys(authClient, { refetchOnMount: false })
+
+  return useMutation({
+    ...addPasskeyOptions(authClient),
+    ...options,
+    onSuccess: async (...args) => {
+      await refetch()
+      await options?.onSuccess?.(...args)
+    }
+  })
+}

package/src/mutations/passkey/delete-passkey-mutation.ts

@@ -0,0 +1,66 @@
+import { passkeyMutationKeys } from "@better-auth-ui/core/plugins"
+import { mutationOptions, useMutation } from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { PasskeyAuthClient } from "../../lib/auth-client"
+import { useListPasskeys } from "../../queries/passkey/list-passkeys-query"
+
+export type DeletePasskeyParams<TAuthClient extends PasskeyAuthClient> =
+  Parameters<TAuthClient["passkey"]["deletePasskey"]>[0]
+
+export type DeletePasskeyOptions<TAuthClient extends PasskeyAuthClient> = Omit<
+  ReturnType<typeof deletePasskeyOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn"
+>
+
+/**
+ * Mutation options factory for deleting a passkey.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function deletePasskeyOptions<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient
+) {
+  const mutationKey = passkeyMutationKeys.deletePasskey
+
+  const mutationFn = (params: DeletePasskeyParams<TAuthClient>) =>
+    authClient.passkey.deletePasskey({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+/**
+ * Create a mutation for deleting a passkey.
+ *
+ * Wraps `authClient.passkey.deletePasskey`, refetches the user's passkey
+ * list on success, and forwards React Query mutation options such as
+ * `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the passkey plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useDeletePasskey<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient,
+  options?: DeletePasskeyOptions<TAuthClient>
+) {
+  const { refetch } = useListPasskeys(authClient, { refetchOnMount: false })
+
+  return useMutation({
+    ...deletePasskeyOptions(authClient),
+    ...options,
+    onSuccess: async (...args) => {
+      await refetch()
+      await options?.onSuccess?.(...args)
+    }
+  })
+}

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

@@ -0,0 +1,74 @@
+import { passkeyMutationKeys } from "@better-auth-ui/core/plugins"
+import {
+  mutationOptions,
+  useMutation,
+  useQueryClient
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { PasskeyAuthClient } from "../../lib/auth-client"
+import { sessionOptions } from "../../queries/auth/session-query"
+
+export type SignInPasskeyParams<TAuthClient extends PasskeyAuthClient> =
+  Parameters<TAuthClient["signIn"]["passkey"]>[0]
+
+export type SignInPasskeyOptions<TAuthClient extends PasskeyAuthClient> = Omit<
+  ReturnType<typeof signInPasskeyOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn"
+>
+
+/**
+ * Mutation options factory for passkey sign-in.
+ *
+ * @param authClient - The Better Auth client with the passkey plugin.
+ */
+export function signInPasskeyOptions<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient
+) {
+  const mutationKey = passkeyMutationKeys.signIn
+
+  // biome-ignore lint/suspicious/noConfusingVoidType: void allows no-arg mutate
+  const mutationFn = (params?: SignInPasskeyParams<TAuthClient> | void) =>
+    authClient.signIn.passkey({
+      ...(params ?? {}),
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+/**
+ * Create a mutation for passkey sign-in.
+ *
+ * Wraps `authClient.signIn.passkey`, resets the session query on success so
+ * the new session is refetched, and forwards React Query mutation options
+ * such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client with the passkey plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useSignInPasskey<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient,
+  options?: SignInPasskeyOptions<TAuthClient>
+) {
+  const queryClient = useQueryClient()
+
+  return useMutation({
+    ...signInPasskeyOptions(authClient),
+    ...options,
+    onSuccess: async (...args) => {
+      queryClient.resetQueries({
+        queryKey: sessionOptions(authClient).queryKey
+      })
+
+      await options?.onSuccess?.(...args)
+    }
+  })
+}

package/src/mutations/settings/change-email-mutation.ts

@@ -0,0 +1,67 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import { mutationOptions, useMutation } from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { AuthClient } from "../../lib/auth-client"
+import { useSession } from "../../queries/auth/session-query"
+
+export type ChangeEmailParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["changeEmail"]
+>[0]
+
+export type ChangeEmailOptions<TAuthClient extends AuthClient> = Omit<
+  ReturnType<typeof changeEmailOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn"
+>
+
+/**
+ * Mutation options factory for changing the current user's email address.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function changeEmailOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  const mutationKey = authMutationKeys.changeEmail
+
+  const mutationFn = (params: ChangeEmailParams<TAuthClient>) =>
+    authClient.changeEmail({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+/**
+ * Create a mutation for changing the current user's email address.
+ *
+ * Wraps `authClient.changeEmail`, refetches the session on success to
+ * surface the new email, and forwards React Query mutation options such
+ * as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useChangeEmail<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  options?: ChangeEmailOptions<TAuthClient>
+) {
+  const { refetch } = useSession(authClient, { refetchOnMount: false })
+
+  return useMutation({
+    ...changeEmailOptions(authClient),
+    ...options,
+    onSuccess: async (...args) => {
+      await refetch()
+      await options?.onSuccess?.(...args)
+    }
+  })
+}

package/src/mutations/settings/change-password-mutation.ts

@@ -0,0 +1,59 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import { mutationOptions, useMutation } from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { AuthClient } from "../../lib/auth-client"
+
+export type ChangePasswordParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["changePassword"]
+>[0]
+
+export type ChangePasswordOptions<TAuthClient extends AuthClient> = Omit<
+  ReturnType<typeof changePasswordOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn"
+>
+
+/**
+ * Mutation options factory for changing the authenticated user's password.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function changePasswordOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  const mutationKey = authMutationKeys.changePassword
+
+  const mutationFn = (params: ChangePasswordParams<TAuthClient>) =>
+    authClient.changePassword({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+/**
+ * Create a mutation for changing the authenticated user's password.
+ *
+ * Wraps `authClient.changePassword` and forwards React Query mutation
+ * options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useChangePassword<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  options?: ChangePasswordOptions<TAuthClient>
+) {
+  return useMutation({
+    ...changePasswordOptions(authClient),
+    ...options
+  })
+}

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

@@ -0,0 +1,59 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import { mutationOptions, useMutation } from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { AuthClient } from "../../lib/auth-client"
+
+export type DeleteUserParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["deleteUser"]
+>[0]
+
+export type DeleteUserOptions<TAuthClient extends AuthClient> = Omit<
+  ReturnType<typeof deleteUserOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn"
+>
+
+/**
+ * Mutation options factory for deleting the authenticated user's account.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function deleteUserOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  const mutationKey = authMutationKeys.deleteUser
+
+  const mutationFn = (params: DeleteUserParams<TAuthClient>) =>
+    authClient.deleteUser({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+/**
+ * Create a mutation for deleting the authenticated user's account.
+ *
+ * Wraps `authClient.deleteUser` and forwards React Query mutation options
+ * such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useDeleteUser<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  options?: DeleteUserOptions<TAuthClient>
+) {
+  return useMutation({
+    ...deleteUserOptions(authClient),
+    ...options
+  })
+}

package/src/mutations/settings/link-social-mutation.ts

@@ -0,0 +1,59 @@
+import { authMutationKeys } from "@better-auth-ui/core"
+import { mutationOptions, useMutation } from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { AuthClient } from "../../lib/auth-client"
+
+export type LinkSocialParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["linkSocial"]
+>[0]
+
+export type LinkSocialOptions<TAuthClient extends AuthClient> = Omit<
+  ReturnType<typeof linkSocialOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn"
+>
+
+/**
+ * Mutation options factory for linking a social provider to the current user.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function linkSocialOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient
+) {
+  const mutationKey = authMutationKeys.linkSocial
+
+  const mutationFn = (params: LinkSocialParams<TAuthClient>) =>
+    authClient.linkSocial({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+/**
+ * Create a mutation for linking a social provider to the current user.
+ *
+ * Wraps `authClient.linkSocial` to initiate a provider redirect and forwards
+ * React Query mutation options such as `onSuccess`, `onError`, and `retry`.
+ *
+ * @param authClient - The Better Auth client.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useLinkSocial<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  options?: LinkSocialOptions<TAuthClient>
+) {
+  return useMutation({
+    ...linkSocialOptions(authClient),
+    ...options
+  })
+}