@better-auth-ui/solid 1.6.19

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

@@ -0,0 +1,124 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins"
+import { createQuery, type QueryClient } from "@tanstack/solid-query"
+import type { OrganizationAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+import { useActiveOrganization } from "./active-organization-query"
+import {
+  createOrganizationQueryOptions,
+  ensureOrganizationQuery,
+  fetchOrganizationQuery,
+  prefetchOrganizationQuery,
+  skipToken
+} from "./utils"
+
+export type ListOrganizationMembersData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Awaited<ReturnType<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>
+) {
+  return createOrganizationQueryOptions(
+    organizationQueryKeys.members.list(userId, params?.query),
+    authClient.organization.listMembers,
+    params
+  )
+}
+
+export const ensureListOrganizationMembers = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationMembersParams<TAuthClient>
+) =>
+  ensureOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.members.list(userId, params?.query),
+    authClient.organization.listMembers,
+    params
+  )
+
+export const prefetchListOrganizationMembers = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationMembersParams<TAuthClient>
+) =>
+  prefetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.members.list(userId, params?.query),
+    authClient.organization.listMembers,
+    params
+  )
+
+export const fetchListOrganizationMembers = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationMembersParams<TAuthClient>
+) =>
+  fetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.members.list(userId, params?.query),
+    authClient.organization.listMembers,
+    params
+  )
+
+export type UseListOrganizationMembersOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = ListOrganizationMembersOptions<TAuthClient> &
+  ListOrganizationMembersParams<TAuthClient>
+
+export function useListOrganizationMembers<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseListOrganizationMembersOptions<TAuthClient> = {}
+) {
+  const session = useSession(authClient)
+  const activeOrganization = useActiveOrganization(authClient, {
+    enabled: !options.query?.organizationId
+  } as never)
+
+  return createQuery(() => {
+    const { query, fetchOptions, ...queryOptionsRest } = options
+    const userId = session.data?.user.id
+    const organizationId = query?.organizationId ?? activeOrganization.data?.id
+    const params = {
+      query: { ...query, organizationId },
+      fetchOptions
+    } as ListOrganizationMembersParams<TAuthClient>
+    const baseOptions = listOrganizationMembersOptions(
+      authClient,
+      userId,
+      params
+    )
+
+    return {
+      ...queryOptionsRest,
+      ...baseOptions,
+      queryFn: userId && organizationId ? baseOptions.queryFn : skipToken
+    }
+  })
+}

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

@@ -0,0 +1,113 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins"
+import { createQuery, type QueryClient } from "@tanstack/solid-query"
+import type { OrganizationAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+import {
+  createOrganizationQueryOptions,
+  ensureOrganizationQuery,
+  fetchOrganizationQuery,
+  prefetchOrganizationQuery,
+  skipToken
+} from "./utils"
+
+export type ListOrganizationsData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Awaited<ReturnType<TAuthClient["organization"]["list"]>>
+
+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>
+) {
+  return createOrganizationQueryOptions(
+    organizationQueryKeys.list(userId, params?.query),
+    authClient.organization.list,
+    params
+  )
+}
+
+export const ensureListOrganizations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationsParams<TAuthClient>
+) =>
+  ensureOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.list(userId, params?.query),
+    authClient.organization.list,
+    params
+  )
+
+export const prefetchListOrganizations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationsParams<TAuthClient>
+) =>
+  prefetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.list(userId, params?.query),
+    authClient.organization.list,
+    params
+  )
+
+export const fetchListOrganizations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationsParams<TAuthClient>
+) =>
+  fetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.list(userId, params?.query),
+    authClient.organization.list,
+    params
+  )
+
+export type UseListOrganizationsOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = ListOrganizationsOptions<TAuthClient> & ListOrganizationsParams<TAuthClient>
+
+export function useListOrganizations<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseListOrganizationsOptions<TAuthClient> = {}
+) {
+  const session = useSession(authClient)
+
+  return createQuery(() => {
+    const { query, fetchOptions, ...queryOptionsRest } = options
+    const userId = session.data?.user.id
+    const baseOptions = listOrganizationsOptions(authClient, userId, {
+      query,
+      fetchOptions
+    } as ListOrganizationsParams<TAuthClient>)
+
+    return {
+      ...queryOptionsRest,
+      ...baseOptions,
+      queryFn: userId ? baseOptions.queryFn : skipToken
+    }
+  })
+}

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

@@ -0,0 +1,114 @@
+import { organizationQueryKeys } from "@better-auth-ui/core/plugins"
+import { createQuery, type QueryClient } from "@tanstack/solid-query"
+import type { OrganizationAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+import {
+  createOrganizationQueryOptions,
+  ensureOrganizationQuery,
+  fetchOrganizationQuery,
+  prefetchOrganizationQuery,
+  skipToken
+} from "./utils"
+
+export type ListUserInvitationsData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Awaited<ReturnType<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>
+) {
+  return createOrganizationQueryOptions(
+    organizationQueryKeys.userInvitations.list(userId, params?.query),
+    authClient.organization.listUserInvitations,
+    params
+  )
+}
+
+export const ensureListUserInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListUserInvitationsParams<TAuthClient>
+) =>
+  ensureOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.userInvitations.list(userId, params?.query),
+    authClient.organization.listUserInvitations,
+    params
+  )
+
+export const prefetchListUserInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListUserInvitationsParams<TAuthClient>
+) =>
+  prefetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.userInvitations.list(userId, params?.query),
+    authClient.organization.listUserInvitations,
+    params
+  )
+
+export const fetchListUserInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListUserInvitationsParams<TAuthClient>
+) =>
+  fetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.userInvitations.list(userId, params?.query),
+    authClient.organization.listUserInvitations,
+    params
+  )
+
+export type UseListUserInvitationsOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = ListUserInvitationsOptions<TAuthClient> &
+  ListUserInvitationsParams<TAuthClient>
+
+export function useListUserInvitations<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseListUserInvitationsOptions<TAuthClient> = {}
+) {
+  const session = useSession(authClient)
+  const { query, fetchOptions, ...queryOptionsRest } = options
+
+  return createQuery(() => {
+    const userId = session.data?.user.id
+    const baseOptions = listUserInvitationsOptions(authClient, userId, {
+      query,
+      fetchOptions
+    } as ListUserInvitationsParams<TAuthClient>)
+
+    return {
+      ...queryOptionsRest,
+      ...baseOptions,
+      queryFn: userId ? baseOptions.queryFn : skipToken
+    }
+  })
+}

package/src/queries/organization/plugin.ts

@@ -0,0 +1,11 @@
+import { organizationPlugin } from "@better-auth-ui/core/plugins"
+import { useAuth } from "../../lib/auth-provider"
+
+export function useOrganizationSlug() {
+  const auth = useAuth()
+  const plugin = auth.plugins?.find(
+    (candidate) => candidate.id === organizationPlugin.id
+  )
+
+  return (plugin as { slug?: string | null } | undefined)?.slug
+}

package/src/queries/organization/utils.ts

@@ -0,0 +1,88 @@
+import {
+  type DataTag,
+  type QueryClient,
+  type QueryKey,
+  queryOptions,
+  skipToken
+} from "@tanstack/solid-query"
+import type { BetterFetchError } from "better-auth/client"
+
+export type OrganizationQueryMethod<TData = unknown> = (
+  // biome-ignore lint/suspicious/noExplicitAny: Better Auth generated methods use plugin-specific params.
+  params?: any
+) => Promise<TData>
+
+export type OrganizationQueryParams<TMethod extends OrganizationQueryMethod> =
+  Parameters<TMethod>[0]
+export type OrganizationQueryData<TMethod extends OrganizationQueryMethod> =
+  Awaited<ReturnType<TMethod>>
+
+export function createOrganizationQueryOptions<
+  TMethod extends OrganizationQueryMethod,
+  const TQueryKey extends QueryKey
+>(
+  queryKey: TQueryKey,
+  authFn: TMethod,
+  params?: OrganizationQueryParams<TMethod>
+) {
+  type TData = OrganizationQueryData<TMethod>
+
+  const options = queryOptions<TData, BetterFetchError, TData, TQueryKey>({
+    queryKey,
+    queryFn: ({ signal }) =>
+      authFn({
+        ...(params ?? {}),
+        fetchOptions: {
+          ...(params as { fetchOptions?: Record<string, unknown> } | undefined)
+            ?.fetchOptions,
+          signal,
+          throw: true
+        }
+      } as OrganizationQueryParams<TMethod>) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<TQueryKey, TData, BetterFetchError>
+  }
+}
+
+export const ensureOrganizationQuery = <
+  TMethod extends OrganizationQueryMethod,
+  const TQueryKey extends QueryKey
+>(
+  queryClient: QueryClient,
+  queryKey: TQueryKey,
+  authFn: TMethod,
+  params?: OrganizationQueryParams<TMethod>
+) =>
+  queryClient.ensureQueryData(
+    createOrganizationQueryOptions(queryKey, authFn, params) as never
+  )
+
+export const prefetchOrganizationQuery = <
+  TMethod extends OrganizationQueryMethod,
+  const TQueryKey extends QueryKey
+>(
+  queryClient: QueryClient,
+  queryKey: TQueryKey,
+  authFn: TMethod,
+  params?: OrganizationQueryParams<TMethod>
+) =>
+  queryClient.prefetchQuery(
+    createOrganizationQueryOptions(queryKey, authFn, params) as never
+  )
+
+export const fetchOrganizationQuery = <
+  TMethod extends OrganizationQueryMethod,
+  const TQueryKey extends QueryKey
+>(
+  queryClient: QueryClient,
+  queryKey: TQueryKey,
+  authFn: TMethod,
+  params?: OrganizationQueryParams<TMethod>
+) =>
+  queryClient.fetchQuery(
+    createOrganizationQueryOptions(queryKey, authFn, params) as never
+  )
+
+export { skipToken }

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

@@ -0,0 +1,93 @@
+import { passkeyQueryKeys } from "@better-auth-ui/core/plugins"
+import type { QueryClient } from "@tanstack/solid-query"
+import type { InferData, PasskeyAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+import {
+  createUserScopedOptions,
+  createUserScopedQuery,
+  ensureUserScopedQuery,
+  fetchUserScopedQuery,
+  getSessionUserId,
+  prefetchUserScopedQuery
+} from "../create-user-scoped-query"
+
+export type ListPasskeysData<TAuthClient extends PasskeyAuthClient> = InferData<
+  TAuthClient["passkey"]["listUserPasskeys"]
+>
+export type ListPasskeysParams<TAuthClient extends PasskeyAuthClient> =
+  Parameters<TAuthClient["passkey"]["listUserPasskeys"]>[0]
+export type ListPasskeysOptions<TAuthClient extends PasskeyAuthClient> = Omit<
+  ReturnType<typeof listPasskeysOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function listPasskeysOptions<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListPasskeysParams<TAuthClient>
+) {
+  return createUserScopedOptions(
+    passkeyQueryKeys.list(userId, params?.query),
+    authClient.passkey.listUserPasskeys,
+    params
+  )
+}
+
+export const ensureListPasskeys = <TAuthClient extends PasskeyAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListPasskeysParams<TAuthClient>
+) =>
+  ensureUserScopedQuery(
+    queryClient,
+    passkeyQueryKeys.list(userId, params?.query),
+    authClient.passkey.listUserPasskeys,
+    params
+  )
+
+export const prefetchListPasskeys = <TAuthClient extends PasskeyAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListPasskeysParams<TAuthClient>
+) =>
+  prefetchUserScopedQuery(
+    queryClient,
+    passkeyQueryKeys.list(userId, params?.query),
+    authClient.passkey.listUserPasskeys,
+    params
+  )
+
+export const fetchListPasskeys = <TAuthClient extends PasskeyAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListPasskeysParams<TAuthClient>
+) =>
+  fetchUserScopedQuery(
+    queryClient,
+    passkeyQueryKeys.list(userId, params?.query),
+    authClient.passkey.listUserPasskeys,
+    params
+  )
+
+export type UseListPasskeysOptions<TAuthClient extends PasskeyAuthClient> =
+  ListPasskeysOptions<TAuthClient> & ListPasskeysParams<TAuthClient>
+
+export function useListPasskeys<TAuthClient extends PasskeyAuthClient>(
+  authClient: TAuthClient,
+  options: UseListPasskeysOptions<TAuthClient> = {}
+) {
+  const session = useSession(authClient)
+  const userId = () => getSessionUserId(session)
+  const { query, fetchOptions, ...queryOptionsRest } = options
+
+  return createUserScopedQuery(
+    () => passkeyQueryKeys.list(userId(), query),
+    authClient.passkey.listUserPasskeys,
+    () => ({ query, fetchOptions }) as ListPasskeysParams<TAuthClient>,
+    () => Boolean(userId()),
+    () => queryOptionsRest
+  )
+}

package/src/queries/settings/account-info-query.ts

@@ -0,0 +1,94 @@
+import { authQueryKeys } from "@better-auth-ui/core"
+import type { QueryClient } from "@tanstack/solid-query"
+import type { AuthClient, InferData } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+import {
+  createUserScopedOptions,
+  createUserScopedQuery,
+  ensureUserScopedQuery,
+  fetchUserScopedQuery,
+  getSessionUserId,
+  prefetchUserScopedQuery
+} from "../create-user-scoped-query"
+
+export type AccountInfoData<TAuthClient extends AuthClient> = InferData<
+  TAuthClient["accountInfo"]
+>
+export type AccountInfoParams<TAuthClient extends AuthClient> = Parameters<
+  TAuthClient["accountInfo"]
+>[0]
+export type AccountInfoOptions<TAuthClient extends AuthClient> = Omit<
+  ReturnType<typeof accountInfoOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function accountInfoOptions<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: AccountInfoParams<TAuthClient>
+) {
+  return createUserScopedOptions(
+    authQueryKeys.accountInfo(userId, params?.query),
+    authClient.accountInfo,
+    params
+  )
+}
+
+export const ensureAccountInfo = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: AccountInfoParams<TAuthClient>
+) =>
+  ensureUserScopedQuery(
+    queryClient,
+    authQueryKeys.accountInfo(userId, params?.query),
+    authClient.accountInfo,
+    params
+  )
+
+export const prefetchAccountInfo = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: AccountInfoParams<TAuthClient>
+) =>
+  prefetchUserScopedQuery(
+    queryClient,
+    authQueryKeys.accountInfo(userId, params?.query),
+    authClient.accountInfo,
+    params
+  )
+
+export const fetchAccountInfo = <TAuthClient extends AuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: AccountInfoParams<TAuthClient>
+) =>
+  fetchUserScopedQuery(
+    queryClient,
+    authQueryKeys.accountInfo(userId, params?.query),
+    authClient.accountInfo,
+    params
+  )
+
+export type UseAccountInfoOptions<TAuthClient extends AuthClient> =
+  AccountInfoOptions<TAuthClient> & AccountInfoParams<TAuthClient>
+
+export function useAccountInfo<TAuthClient extends AuthClient>(
+  authClient: TAuthClient,
+  options: UseAccountInfoOptions<TAuthClient> = {}
+) {
+  const session = useSession(authClient)
+  const userId = () => getSessionUserId(session)
+  const { query, fetchOptions, ...queryOptionsRest } = options
+
+  return createUserScopedQuery(
+    () => authQueryKeys.accountInfo(userId(), query),
+    authClient.accountInfo,
+    () => ({ query, fetchOptions }) as AccountInfoParams<TAuthClient>,
+    () => Boolean(userId() && query?.accountId),
+    () => queryOptionsRest
+  )
+}