@better-auth-ui/react 1.6.8 → 1.6.9

package/src/mutations/organization/remove-member-mutation.ts

@@ -0,0 +1,67 @@
+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 RemoveMemberParams<TAuthClient extends OrganizationAuthClient> =
+  Parameters<TAuthClient["organization"]["removeMember"]>[0]
+
+export type RemoveMemberOptions<TAuthClient extends OrganizationAuthClient> =
+  Omit<
+    ReturnType<typeof removeMemberOptions<TAuthClient>>,
+    "mutationKey" | "mutationFn" | "meta"
+  >
+
+export function removeMemberOptions<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient
+) {
+  const mutationKey = organizationMutationKeys.removeMember
+
+  const mutationFn = (params: RemoveMemberParams<TAuthClient>) =>
+    authClient.organization.removeMember({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+export function useRemoveMember<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient,
+  options?: RemoveMemberOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  return useMutation(
+    {
+      ...removeMemberOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [
+          organizationQueryKeys.members.all(userId),
+          organizationQueryKeys.fullDetails(userId)
+        ],
+        invalidates: [organizationQueryKeys.lists(userId)]
+      }
+    },
+    queryClient
+  )
+}

package/src/mutations/organization/set-active-organization-mutation.ts

@@ -0,0 +1,142 @@
+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"
+import { useListOrganizations } from "../../queries/organization"
+
+export type SetActiveOrganizationParams<
+  TAuthClient extends OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["setActive"]>[0]
+
+export type SetActiveOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof setActiveOrganizationOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn" | "meta"
+>
+
+export function setActiveOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(authClient: TAuthClient) {
+  const mutationKey = organizationMutationKeys.setActive
+
+  const mutationFn = (params: SetActiveOrganizationParams<TAuthClient>) =>
+    authClient.organization.setActive({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+export function useSetActiveOrganization<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options?: SetActiveOrganizationOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+  const { data: organizations } = useListOrganizations(
+    authClient,
+    undefined,
+    queryClient
+  )
+
+  return useMutation(
+    {
+      ...setActiveOrganizationOptions(authClient),
+      ...options,
+      onMutate: async (variables, context) => {
+        // Cancel any outgoing refetches across every slug-partitioned
+        // active-organization cache entry so they don't overwrite our
+        // optimistic update.
+        await context.client.cancelQueries({
+          queryKey: organizationQueryKeys.activeOrganizations(userId)
+        })
+
+        // Snapshot every slug-partitioned variant so the rollback hits
+        // whichever cache entry the UI is actually subscribed to (the
+        // entry's key is `[..., 'active', { organizationSlug }]` when the
+        // plugin's slug option is set, and `[..., 'active', null]`
+        // otherwise).
+        const previousOrganizations = context.client.getQueriesData({
+          queryKey: organizationQueryKeys.activeOrganizations(userId)
+        })
+
+        // Optimistically update to the new value
+        if (variables?.organizationId === null) {
+          context.client.setQueriesData(
+            { queryKey: organizationQueryKeys.activeOrganizations(userId) },
+            null
+          )
+
+          return { previousOrganizations }
+        }
+
+        const newOrganization = organizations?.find(
+          (organization) =>
+            (variables?.organizationId !== undefined &&
+              organization.id === variables.organizationId) ||
+            (variables?.organizationSlug !== undefined &&
+              organization.slug === variables.organizationSlug)
+        )
+
+        if (newOrganization) {
+          context.client.setQueriesData(
+            { queryKey: organizationQueryKeys.activeOrganizations(userId) },
+            newOrganization
+          )
+        }
+
+        return { previousOrganizations }
+      },
+      // If the mutation fails,
+      // use the result returned from onMutate to roll back
+      onError: (error, variables, onMutateResult, context) => {
+        const previousOrganizations = onMutateResult?.previousOrganizations
+
+        if (previousOrganizations?.length && error.error) {
+          for (const [queryKey, data] of previousOrganizations) {
+            context.client.setQueryData(queryKey, data)
+          }
+        }
+
+        return options?.onError?.(error, variables, onMutateResult, context)
+      },
+      // Always refetch after error or success — invalidate every
+      // slug-partitioned variant via the broader prefix.
+      onSettled: async (data, error, variables, onMutateResult, context) => {
+        await context.client.invalidateQueries({
+          queryKey: organizationQueryKeys.activeOrganizations(userId)
+        })
+
+        return options?.onSettled?.(
+          data,
+          error,
+          variables,
+          onMutateResult,
+          context
+        )
+      }
+    },
+    queryClient
+  )
+}

package/src/mutations/organization/update-member-role-mutation.ts

@@ -0,0 +1,81 @@
+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"
+import { useActiveOrganization } from "../../queries/organization"
+
+export type UpdateMemberRoleParams<TAuthClient extends OrganizationAuthClient> =
+  Parameters<TAuthClient["organization"]["updateMemberRole"]>[0]
+
+export type UpdateMemberRoleOptions<
+  TAuthClient extends OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof updateMemberRoleOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn" | "meta"
+>
+
+export function updateMemberRoleOptions<
+  TAuthClient extends OrganizationAuthClient
+>(authClient: TAuthClient) {
+  const mutationKey = organizationMutationKeys.updateMemberRole
+
+  const mutationFn = (params: UpdateMemberRoleParams<TAuthClient>) =>
+    authClient.organization.updateMemberRole({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+export function useUpdateMemberRole<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient,
+  options?: UpdateMemberRoleOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  const { data: activeOrganization } = useActiveOrganization(
+    authClient,
+    undefined,
+    queryClient
+  )
+
+  return useMutation(
+    {
+      ...updateMemberRoleOptions(authClient),
+      ...options,
+      mutationFn: (params: UpdateMemberRoleParams<TAuthClient>) =>
+        authClient.organization.updateMemberRole({
+          ...params,
+          organizationId: params?.organizationId ?? activeOrganization?.id,
+          fetchOptions: { ...params?.fetchOptions, throw: true }
+        }),
+      meta: {
+        awaits: [
+          organizationQueryKeys.members.all(userId),
+          organizationQueryKeys.fullDetails(userId)
+        ],
+        invalidates: [organizationQueryKeys.permissions.all(userId)]
+      }
+    },
+    queryClient
+  )
+}

package/src/mutations/organization/update-organization-mutation.ts

@@ -0,0 +1,84 @@
+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"
+import { useActiveOrganization } from "../../queries/organization"
+
+export type UpdateOrganizationParams<
+  TAuthClient extends OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["update"]>[0]
+
+export type UpdateOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof updateOrganizationOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn" | "meta"
+>
+
+export function updateOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(authClient: TAuthClient) {
+  const mutationKey = organizationMutationKeys.update
+
+  const mutationFn = (params: UpdateOrganizationParams<TAuthClient>) =>
+    authClient.organization.update({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+export function useUpdateOrganization<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options?: UpdateOrganizationOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  const { data: activeOrganization } = useActiveOrganization(
+    authClient,
+    undefined,
+    queryClient
+  )
+
+  return useMutation(
+    {
+      ...updateOrganizationOptions(authClient),
+      ...options,
+      mutationFn: (params: UpdateOrganizationParams<TAuthClient>) =>
+        authClient.organization.update({
+          ...params,
+          organizationId: params?.organizationId ?? activeOrganization?.id,
+          fetchOptions: { ...params?.fetchOptions, throw: true }
+        }),
+      meta: {
+        awaits: [
+          organizationQueryKeys.lists(userId),
+          organizationQueryKeys.fullDetails(userId),
+          organizationQueryKeys.activeOrganizations(userId)
+        ]
+      }
+    },
+    queryClient
+  )
+}

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

@@ -1,15 +1,23 @@
-import { passkeyMutationKeys } from "@better-auth-ui/core/plugins"
-import { mutationOptions, useMutation } from "@tanstack/react-query"
+import {
+  passkeyMutationKeys,
+  passkeyQueryKeys
+} from "@better-auth-ui/core/plugins"
+import {
+  mutationOptions,
+  type QueryClient,
+  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"
+import { useSession } from "../../queries/auth/session-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"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -42,25 +50,28 @@ export function addPasskeyOptions<TAuthClient extends PasskeyAuthClient>(
 /**
  * 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`.
+ * On success, `MutationInvalidator` awaits invalidation of the user's
+ * passkey list (see `meta.awaits`).
  *
  * @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>
+  options?: AddPasskeyOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const { refetch } = useListPasskeys(authClient, { refetchOnMount: false })
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
 
-  return useMutation({
-    ...addPasskeyOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      await refetch()
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...addPasskeyOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [passkeyQueryKeys.lists(userId)]
+      }
+    },
+    queryClient
+  )
 }

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

@@ -1,16 +1,23 @@
-import { passkeyMutationKeys } from "@better-auth-ui/core/plugins"
-import { mutationOptions, useMutation } from "@tanstack/react-query"
+import {
+  passkeyMutationKeys,
+  passkeyQueryKeys
+} from "@better-auth-ui/core/plugins"
+import {
+  mutationOptions,
+  type QueryClient,
+  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"
+import { useSession } from "../../queries/auth/session-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"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -42,25 +49,28 @@ export function deletePasskeyOptions<TAuthClient extends PasskeyAuthClient>(
 /**
  * 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`.
+ * On success, `MutationInvalidator` awaits invalidation of the user's
+ * passkey list (see `meta.awaits`).
  *
  * @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>
+  options?: DeletePasskeyOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const { refetch } = useListPasskeys(authClient, { refetchOnMount: false })
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
 
-  return useMutation({
-    ...deletePasskeyOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      await refetch()
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...deletePasskeyOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [passkeyQueryKeys.lists(userId)]
+      }
+    },
+    queryClient
+  )
 }

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

@@ -1,20 +1,20 @@
+import { authQueryKeys } from "@better-auth-ui/core"
 import { passkeyMutationKeys } 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 { 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"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -47,28 +47,25 @@ export function signInPasskeyOptions<TAuthClient extends PasskeyAuthClient>(
 /**
  * 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`.
+ * 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 passkey plugin.
  * @param options - React Query options forwarded to `useMutation`.
  */
 export function useSignInPasskey<TAuthClient extends PasskeyAuthClient>(
   authClient: TAuthClient,
-  options?: SignInPasskeyOptions<TAuthClient>
+  options?: SignInPasskeyOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const queryClient = useQueryClient()
-
-  return useMutation({
-    ...signInPasskeyOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      queryClient.resetQueries({
-        queryKey: sessionOptions(authClient).queryKey
-      })
-
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...signInPasskeyOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [authQueryKeys.session]
+      }
+    },
+    queryClient
+  )
 }

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

@@ -1,9 +1,12 @@
-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 { useSession } from "../../queries/auth/session-query"
 
 export type ChangeEmailParams<TAuthClient extends AuthClient> = Parameters<
   TAuthClient["changeEmail"]
@@ -11,7 +14,7 @@ export type ChangeEmailParams<TAuthClient extends AuthClient> = Parameters<
 
 export type ChangeEmailOptions<TAuthClient extends AuthClient> = Omit<
   ReturnType<typeof changeEmailOptions<TAuthClient>>,
-  "mutationKey" | "mutationFn"
+  "mutationKey" | "mutationFn" | "meta"
 >
 
 /**
@@ -43,25 +46,26 @@ export function changeEmailOptions<TAuthClient extends AuthClient>(
 /**
  * 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`.
+ * On success, `MutationInvalidator` awaits invalidation of the session
+ * query so the new email is reflected on the user object (see
+ * `meta.awaits`).
  *
  * @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>
+  options?: ChangeEmailOptions<TAuthClient>,
+  queryClient?: QueryClient
 ) {
-  const { refetch } = useSession(authClient, { refetchOnMount: false })
-
-  return useMutation({
-    ...changeEmailOptions(authClient),
-    ...options,
-    onSuccess: async (...args) => {
-      await refetch()
-      await options?.onSuccess?.(...args)
-    }
-  })
+  return useMutation(
+    {
+      ...changeEmailOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [authQueryKeys.session]
+      }
+    },
+    queryClient
+  )
 }

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

@@ -1,4 +1,4 @@
-import { authMutationKeys } from "@better-auth-ui/core"
+import { deleteUserMutationKeys } from "@better-auth-ui/core/plugins"
 import { mutationOptions, useMutation } from "@tanstack/react-query"
 import type { BetterFetchError } from "better-auth/react"
 
@@ -21,7 +21,7 @@ export type DeleteUserOptions<TAuthClient extends AuthClient> = Omit<
 export function deleteUserOptions<TAuthClient extends AuthClient>(
   authClient: TAuthClient
 ) {
-  const mutationKey = authMutationKeys.deleteUser
+  const mutationKey = deleteUserMutationKeys.deleteUser
 
   const mutationFn = (params: DeleteUserParams<TAuthClient>) =>
     authClient.deleteUser({