@better-auth-ui/react 1.6.8 → 1.6.10

package/src/mutations/api-key/create-api-key-mutation.ts

@@ -1,16 +1,26 @@
-import { apiKeyMutationKeys } from "@better-auth-ui/core/plugins"
-import { mutationOptions, useMutation } from "@tanstack/react-query"
+import {
+  apiKeyMutationKeys,
+  apiKeyQueryKeys
+} from "@better-auth-ui/core/plugins"
+import {
+  mutationOptions,
+  type QueryClient,
+  useMutation
+} from "@tanstack/react-query"
 import type { BetterFetchError } from "better-auth/react"
 
 import type { ApiKeyAuthClient } from "../../lib/auth-client"
-import { useListApiKeys } from "../../queries/api-key/list-api-keys-query"
+import { useSession } from "../../queries/auth/session-query"
 
-export type CreateApiKeyParams<TAuthClient extends ApiKeyAuthClient> =
-  Parameters<TAuthClient["apiKey"]["create"]>[0]
+export type CreateApiKeyParams<
+  TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient
+> = Parameters<TAuthClient["apiKey"]["create"]>[0]
 
-export type CreateApiKeyOptions<TAuthClient extends ApiKeyAuthClient> = Omit<
+export type CreateApiKeyOptions<
+  TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient
+> = Omit<
   ReturnType<typeof createApiKeyOptions<TAuthClient>>,
-  "mutationKey" | "mutationFn"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -21,7 +31,7 @@ export type CreateApiKeyOptions<TAuthClient extends ApiKeyAuthClient> = Omit<
 export function createApiKeyOptions<TAuthClient extends ApiKeyAuthClient>(
   authClient: TAuthClient
 ) {
-  const mutationKey = apiKeyMutationKeys.createApiKey
+  const mutationKey = apiKeyMutationKeys.create
 
   const mutationFn = (params: CreateApiKeyParams<TAuthClient>) =>
     authClient.apiKey.create({
@@ -42,23 +52,28 @@ export function createApiKeyOptions<TAuthClient extends ApiKeyAuthClient>(
 /**
  * Create a mutation for creating an API key.
  *
- * Refetches the user's API key list on success unless disabled via options.
+ * On success, `MutationInvalidator` awaits invalidation of the user's API key
+ * list queries (see `meta.awaits`).
  *
  * @param authClient - The Better Auth client with the API key plugin.
  * @param options - React Query options forwarded to `useMutation`.
  */
 export function useCreateApiKey<TAuthClient extends ApiKeyAuthClient>(
   authClient: TAuthClient,
-  options?: CreateApiKeyOptions<TAuthClient>
+  options?: CreateApiKeyOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const { refetch } = useListApiKeys(authClient, { refetchOnMount: false })
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
 
-  return useMutation({
-    ...createApiKeyOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      await refetch()
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...createApiKeyOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [apiKeyQueryKeys.lists(userId)]
+      }
+    },
+    queryClient
+  )
 }

package/src/mutations/api-key/delete-api-key-mutation.ts

@@ -1,16 +1,26 @@
-import { apiKeyMutationKeys } from "@better-auth-ui/core/plugins"
-import { mutationOptions, useMutation } from "@tanstack/react-query"
+import {
+  apiKeyMutationKeys,
+  apiKeyQueryKeys
+} from "@better-auth-ui/core/plugins"
+import {
+  mutationOptions,
+  type QueryClient,
+  useMutation
+} from "@tanstack/react-query"
 import type { BetterFetchError } from "better-auth/react"
 
 import type { ApiKeyAuthClient } from "../../lib/auth-client"
-import { useListApiKeys } from "../../queries/api-key/list-api-keys-query"
+import { useSession } from "../../queries/auth/session-query"
 
-export type DeleteApiKeyParams<TAuthClient extends ApiKeyAuthClient> =
-  Parameters<TAuthClient["apiKey"]["delete"]>[0]
+export type DeleteApiKeyParams<
+  TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient
+> = Parameters<TAuthClient["apiKey"]["delete"]>[0]
 
-export type DeleteApiKeyOptions<TAuthClient extends ApiKeyAuthClient> = Omit<
+export type DeleteApiKeyOptions<
+  TAuthClient extends ApiKeyAuthClient = ApiKeyAuthClient
+> = Omit<
   ReturnType<typeof deleteApiKeyOptions<TAuthClient>>,
-  "mutationKey" | "mutationFn"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -21,7 +31,7 @@ export type DeleteApiKeyOptions<TAuthClient extends ApiKeyAuthClient> = Omit<
 export function deleteApiKeyOptions<TAuthClient extends ApiKeyAuthClient>(
   authClient: TAuthClient
 ) {
-  const mutationKey = apiKeyMutationKeys.deleteApiKey
+  const mutationKey = apiKeyMutationKeys.delete
 
   const mutationFn = (params: DeleteApiKeyParams<TAuthClient>) =>
     authClient.apiKey.delete({
@@ -42,21 +52,28 @@ export function deleteApiKeyOptions<TAuthClient extends ApiKeyAuthClient>(
 /**
  * Create a mutation for deleting an API key.
  *
+ * On success, `MutationInvalidator` awaits invalidation of the user's API key
+ * list queries (see `meta.awaits`).
+ *
  * @param authClient - The Better Auth client with the API key plugin.
  * @param options - React Query options forwarded to `useMutation`.
  */
 export function useDeleteApiKey<TAuthClient extends ApiKeyAuthClient>(
   authClient: TAuthClient,
-  options?: DeleteApiKeyOptions<TAuthClient>
+  options?: DeleteApiKeyOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const { refetch } = useListApiKeys(authClient, { refetchOnMount: false })
-
-  return useMutation({
-    ...deleteApiKeyOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      await refetch()
-      await options?.onSuccess?.(...args)
-    }
-  })
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  return useMutation(
+    {
+      ...deleteApiKeyOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [apiKeyQueryKeys.lists(userId)]
+      }
+    },
+    queryClient
+  )
 }

package/src/mutations/auth/sign-in-email-mutation.ts

@@ -1,13 +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 } from "../../queries/auth/session-query"
 
 export type SignInEmailParams<TAuthClient extends AuthClient> = Parameters<
   TAuthClient["signIn"]["email"]
@@ -15,7 +14,7 @@ export type SignInEmailParams<TAuthClient extends AuthClient> = Parameters<
 
 export type SignInEmailOptions<TAuthClient extends AuthClient> = Omit<
   ReturnType<typeof signInEmailOptions<TAuthClient>>,
-  "mutationKey" | "mutationFn"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -51,28 +50,25 @@ export function signInEmailOptions<TAuthClient extends AuthClient>(
 /**
  * Create a mutation for email/password sign-in.
  *
- * Wraps `authClient.signIn.email`, 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.
  * @param options - React Query options forwarded to `useMutation`.
  */
 export function useSignInEmail<TAuthClient extends AuthClient>(
   authClient: TAuthClient,
-  options?: SignInEmailOptions<TAuthClient>
+  options?: SignInEmailOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const queryClient = useQueryClient()
-
-  return useMutation({
-    ...signInEmailOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      queryClient.resetQueries({
-        queryKey: sessionOptions(authClient).queryKey
-      })
-
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...signInEmailOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [authQueryKeys.session]
+      }
+    },
+    queryClient
+  )
 }

package/src/mutations/auth/sign-out-mutation.ts

@@ -1,6 +1,7 @@
 import { authMutationKeys, authQueryKeys } from "@better-auth-ui/core"
 import {
   mutationOptions,
+  type QueryClient,
   useMutation,
   useQueryClient
 } from "@tanstack/react-query"
@@ -47,25 +48,30 @@ export function signOutOptions<TAuthClient extends AuthClient>(
 /**
  * Create a mutation for signing the current user out.
  *
- * Wraps `authClient.signOut`, removes all cached auth queries on success,
- * and forwards React Query mutation options such as `onSuccess`, `onError`,
- * and `retry`.
+ * On success, removes every cached auth query so no stale data leaks across
+ * accounts. Sign-out uses a direct `removeQueries` call (rather than the
+ * `meta.awaits` / `meta.invalidates` pattern) because the goal is to drop
+ * cache entries entirely, not to refetch them.
  *
  * @param authClient - The Better Auth client.
  * @param options - React Query options forwarded to `useMutation`.
  */
 export function useSignOut<TAuthClient extends AuthClient>(
   authClient: TAuthClient,
-  options?: SignOutOptions<TAuthClient>
+  options?: SignOutOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const queryClient = useQueryClient()
+  const defaultQueryClient = useQueryClient(queryClient)
 
-  return useMutation({
-    ...signOutOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      queryClient.removeQueries({ queryKey: authQueryKeys.all })
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...signOutOptions(authClient),
+      ...options,
+      onSuccess: async (...args) => {
+        defaultQueryClient.removeQueries({ queryKey: authQueryKeys.all })
+        await options?.onSuccess?.(...args)
+      }
+    },
+    queryClient
+  )
 }

package/src/mutations/auth/sign-up-email-mutation.ts

@@ -1,13 +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 } from "../../queries/auth/session-query"
 
 export type SignUpEmailParams<TAuthClient extends AuthClient> = Parameters<
   TAuthClient["signUp"]["email"]
@@ -15,7 +14,7 @@ export type SignUpEmailParams<TAuthClient extends AuthClient> = Parameters<
 
 export type SignUpEmailOptions<TAuthClient extends AuthClient> = Omit<
   ReturnType<typeof signUpEmailOptions<TAuthClient>>,
-  "mutationKey" | "mutationFn"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -47,28 +46,25 @@ export function signUpEmailOptions<TAuthClient extends AuthClient>(
 /**
  * Create a mutation for email/password sign-up.
  *
- * Wraps `authClient.signUp.email`, 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.
  * @param options - React Query options forwarded to `useMutation`.
  */
 export function useSignUpEmail<TAuthClient extends AuthClient>(
   authClient: TAuthClient,
-  options?: SignUpEmailOptions<TAuthClient>
+  options?: SignUpEmailOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const queryClient = useQueryClient()
-
-  return useMutation({
-    ...signUpEmailOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      queryClient.resetQueries({
-        queryKey: sessionOptions(authClient).queryKey
-      })
-
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...signUpEmailOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [authQueryKeys.session]
+      }
+    },
+    queryClient
+  )
 }

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

@@ -1,9 +1,16 @@
-import { authMutationKeys } from "@better-auth-ui/core"
-import { mutationOptions, useMutation } from "@tanstack/react-query"
+import {
+  multiSessionMutationKeys,
+  multiSessionQueryKeys
+} from "@better-auth-ui/core/plugins"
+import {
+  mutationOptions,
+  type QueryClient,
+  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"
+import { useSession } from "../../queries/auth/session-query"
 
 export type RevokeMultiSessionParams<
   TAuthClient extends MultiSessionAuthClient
@@ -13,7 +20,7 @@ export type RevokeMultiSessionOptions<
   TAuthClient extends MultiSessionAuthClient
 > = Omit<
   ReturnType<typeof revokeMultiSessionOptions<TAuthClient>>,
-  "mutationKey" | "mutationFn"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -24,7 +31,7 @@ export type RevokeMultiSessionOptions<
 export function revokeMultiSessionOptions<
   TAuthClient extends MultiSessionAuthClient
 >(authClient: TAuthClient) {
-  const mutationKey = authMutationKeys.multiSession.revoke
+  const mutationKey = multiSessionMutationKeys.revoke
 
   const mutationFn = (params: RevokeMultiSessionParams<TAuthClient>) =>
     authClient.multiSession.revoke({
@@ -45,26 +52,30 @@ export function revokeMultiSessionOptions<
 /**
  * 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`.
+ * On success, `MutationInvalidator` awaits invalidation of the device
+ * sessions list (see `meta.awaits`).
  *
  * @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
-  })
+>(
+  authClient: TAuthClient,
+  options?: RevokeMultiSessionOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
 
-  return useMutation({
-    ...revokeMultiSessionOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      await refetch()
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...revokeMultiSessionOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [multiSessionQueryKeys.lists(userId)]
+      }
+    },
+    queryClient
+  )
 }

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

@@ -1,18 +1,17 @@
-import { authMutationKeys } from "@better-auth-ui/core"
+import { authQueryKeys } from "@better-auth-ui/core"
+import {
+  multiSessionMutationKeys,
+  multiSessionQueryKeys
+} 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 { 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"
+import { useSession } from "../../queries/auth/session-query"
 
 export type SetActiveSessionParams<TAuthClient extends MultiSessionAuthClient> =
   Parameters<TAuthClient["multiSession"]["setActive"]>[0]
@@ -21,7 +20,7 @@ export type SetActiveSessionOptions<
   TAuthClient extends MultiSessionAuthClient
 > = Omit<
   ReturnType<typeof setActiveSessionOptions<TAuthClient>>,
-  "mutationKey" | "mutationFn"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -32,7 +31,7 @@ export type SetActiveSessionOptions<
 export function setActiveSessionOptions<
   TAuthClient extends MultiSessionAuthClient
 >(authClient: TAuthClient) {
-  const mutationKey = authMutationKeys.multiSession.setActive
+  const mutationKey = multiSessionMutationKeys.setActive
 
   const mutationFn = (params: SetActiveSessionParams<TAuthClient>) =>
     authClient.multiSession.setActive({
@@ -53,46 +52,28 @@ export function setActiveSessionOptions<
 /**
  * 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`.
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * and device sessions queries (see `meta.awaits`).
  *
  * @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>
+  options?: SetActiveSessionOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const queryClient = useQueryClient()
-  const { refetch: refetchSession } = useSession(authClient, {
-    refetchOnMount: false
-  })
-  const { data: deviceSessions, refetch: refetchDeviceSessions } =
-    useListDeviceSessions(authClient, {
-      refetchOnMount: false
-    })
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
 
-  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>
-        )
+  return useMutation(
+    {
+      ...setActiveSessionOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [authQueryKeys.session, multiSessionQueryKeys.lists(userId)]
       }
-
-      await refetchSession()
-      await refetchDeviceSessions()
-      await options?.onSuccess?.(data, variables, ...rest)
-    }
-  })
+    },
+    queryClient
+  )
 }

package/src/mutations/organization/accept-invitation-mutation.ts

@@ -0,0 +1,71 @@
+import {
+  organizationMutationKeys,
+  organizationQueryKeys
+} from "@better-auth-ui/core/plugins"
+import {
+  mutationOptions,
+  type QueryClient,
+  useMutation
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { OrganizationAuthClient } from "../../lib/auth-client"
+import { useSession } from "../../queries/auth/session-query"
+
+export type AcceptInvitationParams<TAuthClient extends OrganizationAuthClient> =
+  Parameters<TAuthClient["organization"]["acceptInvitation"]>[0]
+
+export type AcceptInvitationOptions<
+  TAuthClient extends OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof acceptInvitationOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn" | "meta"
+>
+
+export function acceptInvitationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(authClient: TAuthClient) {
+  const mutationKey = organizationMutationKeys.acceptInvitation
+
+  const mutationFn = (params: AcceptInvitationParams<TAuthClient>) =>
+    authClient.organization.acceptInvitation({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+export function useAcceptInvitation<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient,
+  options?: AcceptInvitationOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  return useMutation(
+    {
+      ...acceptInvitationOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [
+          organizationQueryKeys.userInvitations.all(userId),
+          organizationQueryKeys.lists(userId)
+        ],
+        invalidates: [
+          organizationQueryKeys.fullDetails(userId),
+          organizationQueryKeys.activeOrganizations(userId)
+        ]
+      }
+    },
+    queryClient
+  )
+}