@better-auth-ui/solid 1.6.19

package/src/queries/create-user-scoped-query.ts

@@ -0,0 +1,107 @@
+import {
+  createQuery,
+  type DataTag,
+  type QueryClient,
+  type QueryKey,
+  queryOptions,
+  skipToken
+} from "@tanstack/solid-query"
+import type { BetterFetchError } from "better-auth/client"
+
+// biome-ignore lint/suspicious/noExplicitAny: Better Auth client methods have intentionally variable generated params.
+export type QueryMethod<TData = unknown> = (params?: any) => Promise<TData>
+
+export type QueryParams<TMethod extends QueryMethod> = Parameters<TMethod>[0]
+export type QueryData<TMethod extends QueryMethod> = Awaited<
+  ReturnType<TMethod>
+>
+
+export function createUserScopedOptions<
+  TMethod extends QueryMethod,
+  const TQueryKey extends QueryKey
+>(queryKey: TQueryKey, authFn: TMethod, params?: QueryParams<TMethod>) {
+  type TData = QueryData<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 QueryParams<TMethod>) as Promise<TData>
+  })
+
+  return options as typeof options & {
+    queryKey: DataTag<TQueryKey, TData, BetterFetchError>
+  }
+}
+
+export const ensureUserScopedQuery = <
+  TMethod extends QueryMethod,
+  const TQueryKey extends QueryKey
+>(
+  queryClient: QueryClient,
+  queryKey: TQueryKey,
+  authFn: TMethod,
+  params?: QueryParams<TMethod>
+) =>
+  queryClient.ensureQueryData(
+    createUserScopedOptions(queryKey, authFn, params) as never
+  )
+
+export const prefetchUserScopedQuery = <
+  TMethod extends QueryMethod,
+  const TQueryKey extends QueryKey
+>(
+  queryClient: QueryClient,
+  queryKey: TQueryKey,
+  authFn: TMethod,
+  params?: QueryParams<TMethod>
+) =>
+  queryClient.prefetchQuery(
+    createUserScopedOptions(queryKey, authFn, params) as never
+  )
+
+export const fetchUserScopedQuery = <
+  TMethod extends QueryMethod,
+  const TQueryKey extends QueryKey
+>(
+  queryClient: QueryClient,
+  queryKey: TQueryKey,
+  authFn: TMethod,
+  params?: QueryParams<TMethod>
+) =>
+  queryClient.fetchQuery(
+    createUserScopedOptions(queryKey, authFn, params) as never
+  )
+
+export function createUserScopedQuery<
+  TMethod extends QueryMethod,
+  const TQueryKey extends QueryKey
+>(
+  queryKey: () => TQueryKey,
+  authFn: TMethod,
+  params: () => QueryParams<TMethod> | undefined,
+  canFetch: () => boolean,
+  queryOptionsRest: () => Record<string, unknown>
+) {
+  return createQuery(() => {
+    const baseOptions = createUserScopedOptions(queryKey(), authFn, params())
+
+    return {
+      ...queryOptionsRest(),
+      ...baseOptions,
+      queryFn: canFetch() ? baseOptions.queryFn : skipToken
+    }
+  })
+}
+
+export const getSessionUserId = (session: { data?: SessionLike }) =>
+  session.data?.user?.id
+
+type SessionLike = { user?: { id?: string } } | null | undefined

package/src/queries/multi-session/list-device-sessions-query.ts

@@ -0,0 +1,107 @@
+import { multiSessionQueryKeys } from "@better-auth-ui/core/plugins"
+import type { QueryClient } from "@tanstack/solid-query"
+import type { InferData, MultiSessionAuthClient } from "../../lib/auth-client"
+import { useSession } from "../auth/session-query"
+import {
+  createUserScopedOptions,
+  createUserScopedQuery,
+  ensureUserScopedQuery,
+  fetchUserScopedQuery,
+  getSessionUserId,
+  prefetchUserScopedQuery
+} from "../create-user-scoped-query"
+
+export type ListDeviceSessionsData<TAuthClient extends MultiSessionAuthClient> =
+  InferData<TAuthClient["multiSession"]["listDeviceSessions"]>
+export type ListDeviceSessionsParams<
+  TAuthClient extends MultiSessionAuthClient
+> = Parameters<TAuthClient["multiSession"]["listDeviceSessions"]>[0]
+export type ListDeviceSessionsOptions<
+  TAuthClient extends MultiSessionAuthClient
+> = Omit<
+  ReturnType<typeof listDeviceSessionsOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function listDeviceSessionsOptions<
+  TAuthClient extends MultiSessionAuthClient
+>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListDeviceSessionsParams<TAuthClient>
+) {
+  return createUserScopedOptions(
+    multiSessionQueryKeys.list(userId, params?.query),
+    authClient.multiSession.listDeviceSessions,
+    params
+  )
+}
+
+export const ensureListDeviceSessions = <
+  TAuthClient extends MultiSessionAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListDeviceSessionsParams<TAuthClient>
+) =>
+  ensureUserScopedQuery(
+    queryClient,
+    multiSessionQueryKeys.list(userId, params?.query),
+    authClient.multiSession.listDeviceSessions,
+    params
+  )
+
+export const prefetchListDeviceSessions = <
+  TAuthClient extends MultiSessionAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListDeviceSessionsParams<TAuthClient>
+) =>
+  prefetchUserScopedQuery(
+    queryClient,
+    multiSessionQueryKeys.list(userId, params?.query),
+    authClient.multiSession.listDeviceSessions,
+    params
+  )
+
+export const fetchListDeviceSessions = <
+  TAuthClient extends MultiSessionAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string,
+  params?: ListDeviceSessionsParams<TAuthClient>
+) =>
+  fetchUserScopedQuery(
+    queryClient,
+    multiSessionQueryKeys.list(userId, params?.query),
+    authClient.multiSession.listDeviceSessions,
+    params
+  )
+
+export type UseListDeviceSessionsOptions<
+  TAuthClient extends MultiSessionAuthClient
+> = ListDeviceSessionsOptions<TAuthClient> &
+  ListDeviceSessionsParams<TAuthClient>
+
+export function useListDeviceSessions<
+  TAuthClient extends MultiSessionAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseListDeviceSessionsOptions<TAuthClient> = {}
+) {
+  const session = useSession(authClient)
+  const userId = () => getSessionUserId(session)
+  const { query, fetchOptions, ...queryOptionsRest } = options
+
+  return createUserScopedQuery(
+    () => multiSessionQueryKeys.list(userId(), query),
+    authClient.multiSession.listDeviceSessions,
+    () => ({ query, fetchOptions }) as ListDeviceSessionsParams<TAuthClient>,
+    () => Boolean(userId()),
+    () => queryOptionsRest
+  )
+}

package/src/queries/organization/active-organization-query.ts

@@ -0,0 +1,127 @@
+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 type { FullOrganizationParams } from "./full-organization-query"
+import type { ListOrganizationsData } from "./list-organizations-query"
+import { useOrganizationSlug } from "./plugin"
+import {
+  createOrganizationQueryOptions,
+  ensureOrganizationQuery,
+  fetchOrganizationQuery,
+  prefetchOrganizationQuery,
+  skipToken
+} from "./utils"
+
+export type ActiveOrganizationData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> =
+  NonNullable<ListOrganizationsData<TAuthClient>> extends Array<infer TOrg>
+    ? TOrg | null
+    : unknown
+
+export type ActiveOrganizationParams<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = FullOrganizationParams<TAuthClient>
+
+export type ActiveOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof activeOrganizationOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function activeOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ActiveOrganizationParams<TAuthClient>
+) {
+  return createOrganizationQueryOptions(
+    organizationQueryKeys.activeOrganization(userId, params?.query),
+    authClient.organization.getFullOrganization,
+    params
+  )
+}
+
+export const ensureActiveOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ActiveOrganizationParams<TAuthClient>
+) =>
+  ensureOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.activeOrganization(userId, params?.query),
+    authClient.organization.getFullOrganization,
+    params
+  )
+
+export const prefetchActiveOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ActiveOrganizationParams<TAuthClient>
+) =>
+  prefetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.activeOrganization(userId, params?.query),
+    authClient.organization.getFullOrganization,
+    params
+  )
+
+export const fetchActiveOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ActiveOrganizationParams<TAuthClient>
+) =>
+  fetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.activeOrganization(userId, params?.query),
+    authClient.organization.getFullOrganization,
+    params
+  )
+
+export type UseActiveOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = ActiveOrganizationOptions<TAuthClient> &
+  ActiveOrganizationParams<TAuthClient>
+
+export function useActiveOrganization<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseActiveOrganizationOptions<TAuthClient> = {}
+) {
+  const session = useSession(authClient)
+  const slug = useOrganizationSlug()
+
+  return createQuery(() => {
+    const { query, fetchOptions, ...queryOptionsRest } = options
+    const userId = session.data?.user.id
+    const effectiveQuery = slug ? { organizationSlug: slug } : query
+    const baseOptions = activeOrganizationOptions(authClient, userId, {
+      query: effectiveQuery,
+      fetchOptions
+    } as ActiveOrganizationParams<TAuthClient>)
+
+    return {
+      ...queryOptionsRest,
+      ...baseOptions,
+      queryFn:
+        slug === null
+          ? async () => null
+          : userId
+            ? baseOptions.queryFn
+            : skipToken
+    }
+  })
+}

package/src/queries/organization/full-organization-query.ts

@@ -0,0 +1,111 @@
+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 FullOrganizationData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Awaited<ReturnType<TAuthClient["organization"]["getFullOrganization"]>>
+
+export type FullOrganizationParams<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Parameters<TAuthClient["organization"]["getFullOrganization"]>[0]
+
+export type FullOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Omit<
+  ReturnType<typeof fullOrganizationOptions<TAuthClient>>,
+  "queryKey" | "queryFn"
+>
+
+export function fullOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: FullOrganizationParams<TAuthClient>
+) {
+  return createOrganizationQueryOptions(
+    organizationQueryKeys.fullDetail(userId, params?.query),
+    authClient.organization.getFullOrganization,
+    params
+  )
+}
+
+export const ensureFullOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: FullOrganizationParams<TAuthClient>
+) =>
+  ensureOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.fullDetail(userId, params?.query),
+    authClient.organization.getFullOrganization,
+    params
+  )
+
+export const prefetchFullOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: FullOrganizationParams<TAuthClient>
+) =>
+  prefetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.fullDetail(userId, params?.query),
+    authClient.organization.getFullOrganization,
+    params
+  )
+
+export const fetchFullOrganization = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: FullOrganizationParams<TAuthClient>
+) =>
+  fetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.fullDetail(userId, params?.query),
+    authClient.organization.getFullOrganization,
+    params
+  )
+
+export type UseFullOrganizationOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = FullOrganizationOptions<TAuthClient> & FullOrganizationParams<TAuthClient>
+
+export function useFullOrganization<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient,
+  options: UseFullOrganizationOptions<TAuthClient> = {}
+) {
+  const session = useSession(authClient)
+
+  return createQuery(() => {
+    const { query, fetchOptions, ...queryOptionsRest } = options
+    const userId = session.data?.user.id
+    const baseOptions = fullOrganizationOptions(authClient, userId, {
+      query,
+      fetchOptions
+    } as FullOrganizationParams<TAuthClient>)
+
+    return {
+      ...queryOptionsRest,
+      ...baseOptions,
+      queryFn: userId ? baseOptions.queryFn : skipToken
+    }
+  })
+}

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

@@ -0,0 +1,121 @@
+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 HasPermissionData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Awaited<ReturnType<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>
+) {
+  const { fetchOptions, ...query } = params
+
+  return createOrganizationQueryOptions(
+    organizationQueryKeys.permissions.has(userId, query),
+    authClient.organization.hasPermission,
+    { ...query, fetchOptions } as HasPermissionParams<TAuthClient>
+  )
+}
+
+export const ensureHasPermission = <TAuthClient extends OrganizationAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params: HasPermissionParams<TAuthClient>
+) =>
+  ensureOrganizationQuery(
+    queryClient,
+    hasPermissionOptions(authClient, userId, params).queryKey,
+    authClient.organization.hasPermission,
+    params
+  )
+
+export const prefetchHasPermission = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params: HasPermissionParams<TAuthClient>
+) =>
+  prefetchOrganizationQuery(
+    queryClient,
+    hasPermissionOptions(authClient, userId, params).queryKey,
+    authClient.organization.hasPermission,
+    params
+  )
+
+export const fetchHasPermission = <TAuthClient extends OrganizationAuthClient>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params: HasPermissionParams<TAuthClient>
+) =>
+  fetchOrganizationQuery(
+    queryClient,
+    hasPermissionOptions(authClient, userId, params).queryKey,
+    authClient.organization.hasPermission,
+    params
+  )
+
+export type UseHasPermissionOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = HasPermissionOptions<TAuthClient> & HasPermissionParams<TAuthClient>
+
+export function useHasPermission<TAuthClient extends OrganizationAuthClient>(
+  authClient: TAuthClient,
+  options: UseHasPermissionOptions<TAuthClient>
+) {
+  const session = useSession(authClient)
+  const activeOrganization = useActiveOrganization(authClient, {
+    enabled: !options.organizationId
+  } as never)
+
+  return createQuery(() => {
+    const {
+      fetchOptions,
+      permissions,
+      organizationId: optionsOrganizationId,
+      ...queryOptionsRest
+    } = options
+    const userId = session.data?.user.id
+    const organizationId = optionsOrganizationId ?? activeOrganization.data?.id
+    const params = {
+      fetchOptions,
+      organizationId,
+      permissions
+    } as HasPermissionParams<TAuthClient>
+    const baseOptions = hasPermissionOptions(authClient, userId, params)
+
+    return {
+      ...queryOptionsRest,
+      ...baseOptions,
+      queryFn: userId && organizationId ? baseOptions.queryFn : skipToken
+    }
+  })
+}

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,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 ListOrganizationInvitationsData<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = Awaited<ReturnType<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>
+) {
+  return createOrganizationQueryOptions(
+    organizationQueryKeys.invitations.list(userId, params?.query),
+    authClient.organization.listInvitations,
+    params
+  )
+}
+
+export const ensureListOrganizationInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationInvitationsParams<TAuthClient>
+) =>
+  ensureOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.invitations.list(userId, params?.query),
+    authClient.organization.listInvitations,
+    params
+  )
+
+export const prefetchListOrganizationInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationInvitationsParams<TAuthClient>
+) =>
+  prefetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.invitations.list(userId, params?.query),
+    authClient.organization.listInvitations,
+    params
+  )
+
+export const fetchListOrganizationInvitations = <
+  TAuthClient extends OrganizationAuthClient
+>(
+  queryClient: QueryClient,
+  authClient: TAuthClient,
+  userId: string | undefined,
+  params?: ListOrganizationInvitationsParams<TAuthClient>
+) =>
+  fetchOrganizationQuery(
+    queryClient,
+    organizationQueryKeys.invitations.list(userId, params?.query),
+    authClient.organization.listInvitations,
+    params
+  )
+
+export type UseListOrganizationInvitationsOptions<
+  TAuthClient extends OrganizationAuthClient = OrganizationAuthClient
+> = ListOrganizationInvitationsOptions<TAuthClient> &
+  ListOrganizationInvitationsParams<TAuthClient>
+
+export function useListOrganizationInvitations<
+  TAuthClient extends OrganizationAuthClient
+>(
+  authClient: TAuthClient,
+  options: UseListOrganizationInvitationsOptions<TAuthClient> = {}
+) {
+  const session = useSession(authClient)
+  const { query, fetchOptions, ...queryOptionsRest } = options
+  const activeOrganization = useActiveOrganization(authClient, {
+    enabled: !query?.organizationId
+  } as never)
+
+  return createQuery(() => {
+    const userId = session.data?.user.id
+    const organizationId = query?.organizationId ?? activeOrganization.data?.id
+    const params = {
+      query: { ...query, organizationId },
+      fetchOptions
+    } as ListOrganizationInvitationsParams<TAuthClient>
+    const baseOptions = listOrganizationInvitationsOptions(
+      authClient,
+      userId,
+      params
+    )
+
+    return {
+      ...queryOptionsRest,
+      ...baseOptions,
+      queryFn: userId && organizationId ? baseOptions.queryFn : skipToken
+    }
+  })
+}