@better-auth-ui/react 1.6.8 → 1.6.10

package/src/queries/organization/has-permission-query.ts

@@ -0,0 +1,124 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+import { useActiveOrganization } from "./active-organization-query"
+
+export type HasPermissionData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = InferData<TAuthClient["organization"]["hasPermission"]>
+
+export type HasPermissionParams<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["hasPermission"]>[0]
+
+export type HasPermissionOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof hasPermissionOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function hasPermissionOptions<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params: HasPermissionParams<TAuthClient>
+) {
+  type TData = HasPermissionData<TAuthClient>
+  // `hasPermission` is the only org client method without a `query` field — its
+  // params are flat — so the "query" portion is everything except `fetchOptions`.
+  const { fetchOptions, ...query } = params
+  const queryKey = organizationQueryKeys.permissions.has(userId, query)
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.organization.hasPermission({
+          ...query,
+          fetchOptions: { ...fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, BetterFetchError>
+  }
+}
+
+export const ensureHasPermission = <TAuthClient extends OrganizationAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params: HasPermissionParams<TAuthClient>
+) =>
+  queryClient.ensureQueryData(hasPermissionOptions(authClient, userId, params))
+
+export const prefetchHasPermission = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params: HasPermissionParams<TAuthClient>
+) => queryClient.prefetchQuery(hasPermissionOptions(authClient, userId, params))
+
+export const fetchHasPermission = <TAuthClient extends OrganizationAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params: HasPermissionParams<TAuthClient>
+) => queryClient.fetchQuery(hasPermissionOptions(authClient, userId, params))
+
+export type UseHasPermissionOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = HasPermissionOptions<TAuthClient> & HasPermissionParams<TAuthClient>
+
+export function useHasPermission<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient,
+  options: UseHasPermissionOptions<TAuthClient>,
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  const {
+    fetchOptions,
+    permissions,
+    organizationId: optionsOrganizationId,
+    ...queryOptions
+  } = options
+
+  const { data: activeOrganization } = useActiveOrganization(
+    authClient,
+    { enabled: !optionsOrganizationId },
+    queryClient
+  )
+
+  const organizationId = optionsOrganizationId ?? activeOrganization?.id
+
+  const baseOptions = hasPermissionOptions(authClient, userId, {
+    fetchOptions,
+    organizationId,
+    permissions
+  })
+
+  return useQuery(
+    {
+      ...queryOptions,
+      ...baseOptions,
+      queryFn: userId && organizationId ? baseOptions.queryFn : skipToken
+    },
+    queryClient
+  )
+}

package/src/queries/organization/index.ts

@@ -0,0 +1,7 @@
+export * from "./active-organization-query"
+export * from "./full-organization-query"
+export * from "./has-permission-query"
+export * from "./list-invitations-query"
+export * from "./list-members-query"
+export * from "./list-organizations-query"
+export * from "./list-user-invitations-query"

package/src/queries/organization/list-invitations-query.ts

@@ -0,0 +1,133 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+import { useActiveOrganization } from "./active-organization-query"
+
+export type ListOrganizationInvitationsData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = InferData<TAuthClient["organization"]["listInvitations"]>
+
+export type ListOrganizationInvitationsParams<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["listInvitations"]>[0]
+
+export type ListOrganizationInvitationsOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof listOrganizationInvitationsOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function listOrganizationInvitationsOptions<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationInvitationsParams<TAuthClient>
+) {
+  type TData = ListOrganizationInvitationsData<TAuthClient>
+  const queryKey = organizationQueryKeys.invitations.list(userId, params?.query)
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.organization.listInvitations({
+          ...params,
+          fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, BetterFetchError>
+  }
+}
+
+export const ensureListOrganizationInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationInvitationsParams<TAuthClient>
+) =>
+  queryClient.ensureQueryData(
+    listOrganizationInvitationsOptions(authClient, userId, params)
+  )
+
+export const prefetchListOrganizationInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationInvitationsParams<TAuthClient>
+) =>
+  queryClient.prefetchQuery(
+    listOrganizationInvitationsOptions(authClient, userId, params)
+  )
+
+export const fetchListOrganizationInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationInvitationsParams<TAuthClient>
+) =>
+  queryClient.fetchQuery(
+    listOrganizationInvitationsOptions(authClient, userId, params)
+  )
+
+export type UseListOrganizationInvitationsOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = ListOrganizationInvitationsOptions<TAuthClient> &
+  ListOrganizationInvitationsParams<TAuthClient>
+
+export function useListOrganizationInvitations<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseListOrganizationInvitationsOptions<TAuthClient> = {},
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  const { query, fetchOptions, ...queryOptions } = options
+
+  const { data: activeOrganization } = useActiveOrganization(
+    authClient,
+    { enabled: !query?.organizationId },
+    queryClient
+  )
+
+  const organizationId = query?.organizationId ?? activeOrganization?.id
+
+  const baseOptions = listOrganizationInvitationsOptions(authClient, userId, {
+    query: {
+      ...query,
+      organizationId
+    },
+    fetchOptions
+  })
+
+  return useQuery(
+    {
+      ...queryOptions,
+      ...baseOptions,
+      queryFn: userId && organizationId ? baseOptions.queryFn : skipToken
+    },
+    queryClient
+  )
+}

package/src/queries/organization/list-members-query.ts

@@ -0,0 +1,133 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+import { useActiveOrganization } from "./active-organization-query"
+
+export type ListOrganizationMembersData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = InferData<TAuthClient["organization"]["listMembers"]>
+
+export type ListOrganizationMembersParams<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["listMembers"]>[0]
+
+export type ListOrganizationMembersOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof listOrganizationMembersOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function listOrganizationMembersOptions<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationMembersParams<TAuthClient>
+) {
+  type TData = ListOrganizationMembersData<TAuthClient>
+  const queryKey = organizationQueryKeys.members.list(userId, params?.query)
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.organization.listMembers({
+          ...params,
+          fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, BetterFetchError>
+  }
+}
+
+export const ensureListOrganizationMembers = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationMembersParams<TAuthClient>
+) =>
+  queryClient.ensureQueryData(
+    listOrganizationMembersOptions(authClient, userId, params)
+  )
+
+export const prefetchListOrganizationMembers = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationMembersParams<TAuthClient>
+) =>
+  queryClient.prefetchQuery(
+    listOrganizationMembersOptions(authClient, userId, params)
+  )
+
+export const fetchListOrganizationMembers = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationMembersParams<TAuthClient>
+) =>
+  queryClient.fetchQuery(
+    listOrganizationMembersOptions(authClient, userId, params)
+  )
+
+export type UseListOrganizationMembersOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = ListOrganizationMembersOptions<TAuthClient> &
+  ListOrganizationMembersParams<TAuthClient>
+
+export function useListOrganizationMembers<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseListOrganizationMembersOptions<TAuthClient> = {},
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  const { query, fetchOptions, ...queryOptions } = options
+
+  const { data: activeOrganization } = useActiveOrganization(
+    authClient,
+    { enabled: !query?.organizationId },
+    queryClient
+  )
+
+  const organizationId = query?.organizationId ?? activeOrganization?.id
+
+  const baseOptions = listOrganizationMembersOptions(authClient, userId, {
+    query: {
+      ...query,
+      organizationId
+    },
+    fetchOptions
+  })
+
+  return useQuery(
+    {
+      ...queryOptions,
+      ...baseOptions,
+      queryFn: userId && organizationId ? baseOptions.queryFn : skipToken
+    },
+    queryClient
+  )
+}

package/src/queries/organization/list-organizations-query.ts

@@ -0,0 +1,122 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+
+export type ListOrganizationsData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = InferData<TAuthClient["organization"]["list"]>
+
+export type ListOrganization<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = NonNullable<ListOrganizationsData<TAuthClient>>[number]
+
+export type ListOrganizationsParams<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["list"]>[0]
+
+export type ListOrganizationsOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof listOrganizationsOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function listOrganizationsOptions<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationsParams<TAuthClient>
+) {
+  type TData = ListOrganizationsData<TAuthClient>
+  const queryKey = organizationQueryKeys.list(userId, params?.query)
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.organization.list({
+          ...params,
+          fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, BetterFetchError>
+  }
+}
+
+export const ensureListOrganizations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListOrganizationsParams<TAuthClient>
+) =>
+  queryClient.ensureQueryData(
+    listOrganizationsOptions(authClient, userId, params)
+  )
+
+export const prefetchListOrganizations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListOrganizationsParams<TAuthClient>
+) =>
+  queryClient.prefetchQuery(
+    listOrganizationsOptions(authClient, userId, params)
+  )
+
+export const fetchListOrganizations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListOrganizationsParams<TAuthClient>
+) =>
+  queryClient.fetchQuery(listOrganizationsOptions(authClient, userId, params))
+
+export type UseListOrganizationsOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = ListOrganizationsOptions<TAuthClient> & ListOrganizationsParams<TAuthClient>
+
+export function useListOrganizations<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseListOrganizationsOptions<TAuthClient> = {},
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  const { query, fetchOptions, ...queryOptionsRest } = options
+
+  const baseOptions = listOrganizationsOptions(authClient, userId, {
+    query,
+    fetchOptions
+  })
+
+  return useQuery(
+    {
+      ...queryOptionsRest,
+      ...baseOptions,
+      queryFn: userId ? baseOptions.queryFn : skipToken
+    },
+    queryClient
+  )
+}

package/src/queries/organization/list-user-invitations-query.ts

@@ -0,0 +1,122 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins"
+import {
+  type DataTag,
+  type QueryClient,
+  queryOptions,
+  skipToken,
+  useQuery
+} from "@tanstack/react-query"
+import type { BetterFetchError } from "better-auth/react"
+
+import type { InferData, OrganizationAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+
+export type ListUserInvitationsData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = InferData<TAuthClient["organization"]["listUserInvitations"]>
+
+export type ListUserInvitationsParams<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["listUserInvitations"]>[0]
+
+export type ListUserInvitationsOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof listUserInvitationsOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function listUserInvitationsOptions<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListUserInvitationsParams<TAuthClient>
+) {
+  type TData = ListUserInvitationsData<TAuthClient>
+  const queryKey = organizationQueryKeys.userInvitations.list(
+    userId,
+    params?.query
+  )
+
+  const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
+    {
+      queryKey,
+      queryFn: ({ signal }) =>
+        authClient.organization.listUserInvitations({
+          ...params,
+          fetchOptions: { ...params?.fetchOptions, signal, throw: true }
+        }) as Promise<TData>
+    }
+  )
+
+  return options as typeof options & {
+    queryKey: DataTag<typeof queryKey, TData, BetterFetchError>
+  }
+}
+
+export const ensureListUserInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListUserInvitationsParams<TAuthClient>
+) =>
+  queryClient.ensureQueryData(
+    listUserInvitationsOptions(authClient, userId, params)
+  )
+
+export const prefetchListUserInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListUserInvitationsParams<TAuthClient>
+) =>
+  queryClient.prefetchQuery(
+    listUserInvitationsOptions(authClient, userId, params)
+  )
+
+export const fetchListUserInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListUserInvitationsParams<TAuthClient>
+) =>
+  queryClient.fetchQuery(listUserInvitationsOptions(authClient, userId, params))
+
+export type UseListUserInvitationsOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = ListUserInvitationsOptions<TAuthClient> &
+  ListUserInvitationsParams<TAuthClient>
+
+export function useListUserInvitations<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseListUserInvitationsOptions<TAuthClient> = {},
+  queryClient?: QueryClient
+) {
+  const { data: session } = useSession(authClient, undefined, queryClient)
+  const userId = session?.user.id
+
+  const { query, fetchOptions, ...queryOptions } = options
+
+  const baseOptions = listUserInvitationsOptions(authClient, userId, {
+    query,
+    fetchOptions
+  })
+
+  return useQuery(
+    {
+      ...queryOptions,
+      ...baseOptions,
+      queryFn: userId ? baseOptions.queryFn : skipToken
+    },
+    queryClient
+  )
+}

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

@@ -1,4 +1,4 @@
-import { authQueryKeys } from "@better-auth-ui/core"
+import { passkeyQueryKeys } from "@better-auth-ui/core/plugins"
 import {
   type DataTag,
   type QueryClient,
@@ -40,7 +40,7 @@ export function listPasskeysOptions<TAuthClient extends PasskeyAuthClient>(
   params?: ListPasskeysParams<TAuthClient>
 ) {
   type TData = ListPasskeysData<TAuthClient>
-  const queryKey = authQueryKeys.listPasskeys(userId, params?.query)
+  const queryKey = passkeyQueryKeys.list(userId, params?.query)
 
   const options = queryOptions<TData, BetterFetchError, TData, typeof queryKey>(
     {