@better-auth-ui/react 1.6.8 → 1.6.9

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
+  )
+}

package/src/mutations/organization/cancel-invitation-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 CancelInvitationParams<TAuthClient extends OrganizationAuthClient> =
+  Parameters<TAuthClient["organization"]["cancelInvitation"]>[0]
+
+export type CancelInvitationOptions<
+  TAuthClient extends OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof cancelInvitationOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn" | "meta"
+>
+
+export function cancelInvitationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(authClient: TAuthClient) {
+  const mutationKey = organizationMutationKeys.cancelInvitation
+
+  const mutationFn = (params: CancelInvitationParams<TAuthClient>) =>
+    authClient.organization.cancelInvitation({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+export function useCancelInvitation<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient,
+  options?: CancelInvitationOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  return useMutation(
+    {
+      ...cancelInvitationOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [
+          organizationQueryKeys.invitations.all(userId),
+          organizationQueryKeys.fullDetails(userId)
+        ]
+      }
+    },
+    queryClient
+  )
+}

package/src/mutations/organization/check-slug-mutation.ts

@@ -0,0 +1,55 @@
+import { organizationMutationKeys } from "@better-auth-ui/core/plugins"
+import { mutationOptions, useMutation } from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { OrganizationAuthClient } from "../../lib/auth-client"
+
+export type CheckSlugParams<TAuthClient extends OrganizationAuthClient> =
+  Parameters<TAuthClient["organization"]["checkSlug"]>[0]
+
+export type CheckSlugOptions<TAuthClient extends OrganizationAuthClient> = Omit<
+  ReturnType<typeof checkSlugOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn"
+>
+
+/**
+ * Mutation options factory for checking organization slug availability.
+ *
+ * @param authClient - The Better Auth client.
+ */
+export function checkSlugOptions<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient
+) {
+  const mutationKey = organizationMutationKeys.checkSlug
+
+  const mutationFn = (params: CheckSlugParams<TAuthClient>) =>
+    authClient.organization.checkSlug({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+/**
+ * Create a mutation for checking whether an organization slug is available.
+ *
+ * @param authClient - The Better Auth client with the organization plugin.
+ * @param options - React Query options forwarded to `useMutation`.
+ */
+export function useCheckSlug<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient,
+  options?: CheckSlugOptions<TAuthClient>
+) {
+  return useMutation({
+    ...checkSlugOptions(authClient),
+    ...options
+  })
+}

package/src/mutations/organization/create-organization-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 CreateOrganizationParams<
+  TAuthClient extends OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["create"]>[0]
+
+export type CreateOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof createOrganizationOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn" | "meta"
+>
+
+export function createOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(authClient: TAuthClient) {
+  const mutationKey = organizationMutationKeys.create
+
+  const mutationFn = (params: CreateOrganizationParams<TAuthClient>) =>
+    authClient.organization.create({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+export function useCreateOrganization<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options?: CreateOrganizationOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  return useMutation(
+    {
+      ...createOrganizationOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [organizationQueryKeys.lists(userId)],
+        invalidates: [
+          organizationQueryKeys.fullDetails(userId),
+          organizationQueryKeys.activeOrganizations(userId)
+        ]
+      }
+    },
+    queryClient
+  )
+}

package/src/mutations/organization/delete-organization-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 DeleteOrganizationParams<
+  TAuthClient extends OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["delete"]>[0]
+
+export type DeleteOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof deleteOrganizationOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn" | "meta"
+>
+
+export function deleteOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(authClient: TAuthClient) {
+  const mutationKey = organizationMutationKeys.delete
+
+  const mutationFn = (params: DeleteOrganizationParams<TAuthClient>) =>
+    authClient.organization.delete({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+export function useDeleteOrganization<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options?: DeleteOrganizationOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  return useMutation(
+    {
+      ...deleteOrganizationOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [organizationQueryKeys.lists(userId)],
+        invalidates: [
+          organizationQueryKeys.fullDetails(userId),
+          organizationQueryKeys.activeOrganizations(userId)
+        ]
+      }
+    },
+    queryClient
+  )
+}

package/src/mutations/organization/index.ts

@@ -0,0 +1,12 @@
+export * from "./accept-invitation-mutation"
+export * from "./cancel-invitation-mutation"
+export * from "./check-slug-mutation"
+export * from "./create-organization-mutation"
+export * from "./delete-organization-mutation"
+export * from "./invite-member-mutation"
+export * from "./leave-organization-mutation"
+export * from "./reject-invitation-mutation"
+export * from "./remove-member-mutation"
+export * from "./set-active-organization-mutation"
+export * from "./update-member-role-mutation"
+export * from "./update-organization-mutation"

package/src/mutations/organization/invite-member-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 InviteMemberParams<TAuthClient extends OrganizationAuthClient> =
+  Parameters<TAuthClient["organization"]["inviteMember"]>[0]
+
+export type InviteMemberOptions<TAuthClient extends OrganizationAuthClient> =
+  Omit<
+    ReturnType<typeof inviteMemberOptions<TAuthClient>>,
+    "mutationKey" | "mutationFn" | "meta"
+  >
+
+export function inviteMemberOptions<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient
+) {
+  const mutationKey = organizationMutationKeys.inviteMember
+
+  const mutationFn = (params: InviteMemberParams<TAuthClient>) =>
+    authClient.organization.inviteMember({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+export function useInviteMember<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options?: InviteMemberOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  const { data: activeOrganization } = useActiveOrganization(
+    authClient,
+    undefined,
+    queryClient
+  )
+
+  return useMutation(
+    {
+      ...inviteMemberOptions(authClient),
+      ...options,
+      mutationFn: (params: InviteMemberParams<TAuthClient>) =>
+        authClient.organization.inviteMember({
+          ...params,
+          organizationId: params?.organizationId ?? activeOrganization?.id,
+          fetchOptions: { ...params?.fetchOptions, throw: true }
+        }),
+      meta: {
+        awaits: [
+          organizationQueryKeys.invitations.all(userId),
+          organizationQueryKeys.fullDetails(userId)
+        ]
+      }
+    },
+    queryClient
+  )
+}

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

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

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

@@ -0,0 +1,64 @@
+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 RejectInvitationParams<TAuthClient extends OrganizationAuthClient> =
+  Parameters<TAuthClient["organization"]["rejectInvitation"]>[0]
+
+export type RejectInvitationOptions<
+  TAuthClient extends OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof rejectInvitationOptions<TAuthClient>>,
+  "mutationKey" | "mutationFn" | "meta"
+>
+
+export function rejectInvitationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(authClient: TAuthClient) {
+  const mutationKey = organizationMutationKeys.rejectInvitation
+
+  const mutationFn = (params: RejectInvitationParams<TAuthClient>) =>
+    authClient.organization.rejectInvitation({
+      ...params,
+      fetchOptions: { ...params?.fetchOptions, throw: true }
+    })
+
+  return mutationOptions<
+    Awaited<ReturnType<typeof mutationFn>>,
+    BetterFetchError,
+    Parameters<typeof mutationFn>[0]
+  >({
+    mutationKey,
+    mutationFn
+  })
+}
+
+export function useRejectInvitation<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient,
+  options?: RejectInvitationOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  return useMutation(
+    {
+      ...rejectInvitationOptions(authClient),
+      ...options,
+      meta: {
+        awaits: [organizationQueryKeys.userInvitations.all(userId)]
+      }
+    },
+    queryClient
+  )
+}