@better-auth-ui/react 1.6.9 → 1.6.10

package/dist/queries/organization/list-organizations-query.js

@@ -1,31 +0,0 @@
-import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-export function listOrganizationsOptions(authClient, userId, params) {
-    const queryKey = organizationQueryKeys.list(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.organization.list({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-export const ensureListOrganizations = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listOrganizationsOptions(authClient, userId, params));
-export const prefetchListOrganizations = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listOrganizationsOptions(authClient, userId, params));
-export const fetchListOrganizations = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listOrganizationsOptions(authClient, userId, params));
-export function useListOrganizations(authClient, options = {}, 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/dist/queries/organization/list-user-invitations-query.js

@@ -1,31 +0,0 @@
-import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-export function listUserInvitationsOptions(authClient, userId, params) {
-    const queryKey = organizationQueryKeys.userInvitations.list(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.organization.listUserInvitations({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-export const ensureListUserInvitations = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listUserInvitationsOptions(authClient, userId, params));
-export const prefetchListUserInvitations = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listUserInvitationsOptions(authClient, userId, params));
-export const fetchListUserInvitations = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listUserInvitationsOptions(authClient, userId, params));
-export function useListUserInvitations(authClient, options = {}, 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/dist/queries/passkey/list-passkeys-query.js

@@ -1,83 +0,0 @@
-import { passkeyQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-/**
- * Query options factory for the current user's passkeys.
- *
- * @param authClient - The Better Auth client with the passkey plugin.
- * @param userId - The current signed-in user's ID. Used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.passkey.listUserPasskeys`.
- */
-export function listPasskeysOptions(authClient, userId, params) {
-    const queryKey = passkeyQueryKeys.list(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.passkey.listUserPasskeys({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-/**
- * Get the current user's passkeys from the query cache, calling
- * `fetchListPasskeys` under the hood if no cached entry exists. Resolves
- * with the passkey list, making it ideal for loaders or `beforeLoad` guards.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client with the passkey plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.passkey.listUserPasskeys`.
- */
-export const ensureListPasskeys = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listPasskeysOptions(authClient, userId, params));
-/**
- * Prefetch the current user's passkeys into the query cache. Behaves like
- * `fetchListPasskeys`, but does not throw on error and does not return
- * the data — use this to warm the cache without blocking navigation.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client with the passkey plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.passkey.listUserPasskeys`.
- */
-export const prefetchListPasskeys = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listPasskeysOptions(authClient, userId, params));
-/**
- * Fetch and cache the current user's passkeys, resolving with the data or
- * throwing on error. If a cached entry exists and is neither invalidated
- * nor older than `staleTime`, the cached value is returned without a
- * network call; otherwise the latest data is fetched.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client with the passkey plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.passkey.listUserPasskeys`.
- */
-export const fetchListPasskeys = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listPasskeysOptions(authClient, userId, params));
-/**
- * Subscribe to the current user's passkeys via TanStack Query.
- *
- * Shares a query key with the server-side `listPasskeysOptions`, so
- * SSR-hydrated data is reused from the cache without an immediate refetch.
- * The query is gated on a signed-in user; while the session is loading or
- * absent, the underlying `queryFn` is replaced with `skipToken`.
- *
- * @param authClient - The Better Auth client with the passkey plugin.
- * @param options - `listPasskeys` params (`query`, `fetchOptions`) merged
- *   with `useQuery` options (e.g. `enabled`, `staleTime`, `select`).
- * @param queryClient - Optional custom `QueryClient`. Defaults to the client
- *   from the nearest `QueryClientProvider`.
- */
-export function useListPasskeys(authClient, options = {}, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    const { query, fetchOptions, ...queryOptions } = options;
-    const baseOptions = listPasskeysOptions(authClient, userId, {
-        query,
-        fetchOptions
-    });
-    return useQuery({
-        ...queryOptions,
-        ...baseOptions,
-        queryFn: userId ? baseOptions.queryFn : skipToken
-    }, queryClient);
-}

package/dist/queries/settings/account-info-query.js

@@ -1,87 +0,0 @@
-import { authQueryKeys } from "@better-auth-ui/core";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-/**
- * Query options factory for provider-specific account info.
- *
- * @param authClient - The Better Auth client.
- * @param userId - The current signed-in user's ID. Used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.accountInfo`.
- */
-export function accountInfoOptions(authClient, userId, params) {
-    const queryKey = authQueryKeys.accountInfo(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.accountInfo({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-/**
- * Get the current user's provider-specific account info from the query
- * cache, calling `fetchAccountInfo` under the hood if no cached entry
- * exists. Resolves with the data, making it ideal for loaders or
- * `beforeLoad` guards.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.accountInfo`.
- */
-export const ensureAccountInfo = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(accountInfoOptions(authClient, userId, params));
-/**
- * Prefetch the current user's provider-specific account info into the query
- * cache. Behaves like `fetchAccountInfo`, but does not throw on error and
- * does not return the data — use this to warm the cache without blocking
- * navigation.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.accountInfo`.
- */
-export const prefetchAccountInfo = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(accountInfoOptions(authClient, userId, params));
-/**
- * Fetch and cache the current user's provider-specific account info,
- * resolving with the data or throwing on error. If a cached entry exists
- * and is neither invalidated nor older than `staleTime`, the cached value
- * is returned without a network call; otherwise the latest data is fetched.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.accountInfo`.
- */
-export const fetchAccountInfo = (queryClient, authClient, userId, params) => queryClient.fetchQuery(accountInfoOptions(authClient, userId, params));
-/**
- * Subscribe to provider-specific info for a linked account via TanStack Query.
- *
- * Shares a query key with the server-side `accountInfoOptions`, so
- * SSR-hydrated data is reused from the cache without an immediate refetch.
- * The query is gated on both a signed-in user and a resolved `accountId`;
- * until both are present, the underlying `queryFn` is replaced with
- * `skipToken`.
- *
- * @param authClient - The Better Auth client.
- * @param options - `accountInfo` params (`query`, `fetchOptions`) merged
- *   with `useQuery` options (e.g. `enabled`, `staleTime`, `select`).
- * @param queryClient - Optional custom `QueryClient`. Defaults to the client
- *   from the nearest `QueryClientProvider`.
- */
-export function useAccountInfo(authClient, options = {}, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    const { query, fetchOptions, ...queryOptions } = options;
-    const baseOptions = accountInfoOptions(authClient, userId, {
-        query,
-        fetchOptions
-    });
-    const canFetch = Boolean(userId && query?.accountId);
-    return useQuery({
-        ...queryOptions,
-        ...baseOptions,
-        queryFn: canFetch ? baseOptions.queryFn : skipToken
-    }, queryClient);
-}

package/dist/queries/settings/list-accounts-query.js

@@ -1,85 +0,0 @@
-import { authQueryKeys } from "@better-auth-ui/core";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-/**
- * Query options factory for a user's linked social accounts.
- *
- * @param authClient - The Better Auth client.
- * @param userId - The current signed-in user's ID. Used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.listAccounts`.
- */
-export function listAccountsOptions(authClient, userId, params) {
-    const queryKey = authQueryKeys.listAccounts(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.listAccounts({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-/**
- * Get the current user's linked social accounts from the query cache,
- * calling `fetchListAccounts` under the hood if no cached entry exists.
- * Resolves with the account list, making it ideal for loaders or
- * `beforeLoad` guards.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.listAccounts`.
- */
-export const ensureListAccounts = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listAccountsOptions(authClient, userId, params));
-/**
- * Prefetch the current user's linked social accounts into the query cache.
- * Behaves like `fetchListAccounts`, but does not throw on error and does
- * not return the data — use this to warm the cache without blocking
- * navigation.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.listAccounts`.
- */
-export const prefetchListAccounts = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listAccountsOptions(authClient, userId, params));
-/**
- * Fetch and cache the current user's linked social accounts, resolving
- * with the data or throwing on error. If a cached entry exists and is
- * neither invalidated nor older than `staleTime`, the cached value is
- * returned without a network call; otherwise the latest data is fetched.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.listAccounts`.
- */
-export const fetchListAccounts = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listAccountsOptions(authClient, userId, params));
-/**
- * Subscribe to the current user's linked social accounts via TanStack Query.
- *
- * Shares a query key with the server-side `listAccountsOptions`, so
- * SSR-hydrated data is reused from the cache without an immediate refetch.
- * The query is gated on a signed-in user; while the session is loading or
- * absent, the underlying `queryFn` is replaced with `skipToken`.
- *
- * @param authClient - The Better Auth client.
- * @param options - `listAccounts` params (`query`, `fetchOptions`) merged
- *   with `useQuery` options (e.g. `enabled`, `staleTime`, `select`).
- * @param queryClient - Optional custom `QueryClient`. Defaults to the client
- *   from the nearest `QueryClientProvider`.
- */
-export function useListAccounts(authClient, options = {}, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    const { query, fetchOptions, ...queryOptions } = options;
-    const baseOptions = listAccountsOptions(authClient, userId, {
-        query,
-        fetchOptions
-    });
-    return useQuery({
-        ...queryOptions,
-        ...baseOptions,
-        queryFn: userId ? baseOptions.queryFn : skipToken
-    }, queryClient);
-}

package/dist/queries/settings/list-sessions-query.js

@@ -1,83 +0,0 @@
-import { authQueryKeys } from "@better-auth-ui/core";
-import { queryOptions, skipToken, useQuery } from "@tanstack/react-query";
-import { useSession } from "../auth/session-query";
-/**
- * Query options factory for the current user's active sessions.
- *
- * @param authClient - The Better Auth client.
- * @param userId - The current signed-in user's ID. Used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.listSessions`.
- */
-export function listSessionsOptions(authClient, userId, params) {
-    const queryKey = authQueryKeys.listSessions(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: ({ signal }) => authClient.listSessions({
-            ...params,
-            fetchOptions: { ...params?.fetchOptions, signal, throw: true }
-        })
-    });
-    return options;
-}
-/**
- * Get the current user's active sessions from the query cache, calling
- * `fetchListSessions` under the hood if no cached entry exists. Resolves
- * with the session list, making it ideal for loaders or `beforeLoad` guards.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.listSessions`.
- */
-export const ensureListSessions = (queryClient, authClient, userId, params) => queryClient.ensureQueryData(listSessionsOptions(authClient, userId, params));
-/**
- * Prefetch the current user's active sessions into the query cache. Behaves
- * like `fetchListSessions`, but does not throw on error and does not return
- * the data — use this to warm the cache without blocking navigation.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.listSessions`.
- */
-export const prefetchListSessions = (queryClient, authClient, userId, params) => queryClient.prefetchQuery(listSessionsOptions(authClient, userId, params));
-/**
- * Fetch and cache the current user's active sessions, resolving with the
- * data or throwing on error. If a cached entry exists and is neither
- * invalidated nor older than `staleTime`, the cached value is returned
- * without a network call; otherwise the latest data is fetched.
- *
- * @param queryClient - The React Query client.
- * @param authClient - The Better Auth client.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `authClient.listSessions`.
- */
-export const fetchListSessions = (queryClient, authClient, userId, params) => queryClient.fetchQuery(listSessionsOptions(authClient, userId, params));
-/**
- * Subscribe to the current user's active sessions via TanStack Query.
- *
- * Shares a query key with the server-side `listSessionsOptions`, so
- * SSR-hydrated data is reused from the cache without an immediate refetch.
- * The query is gated on a signed-in user; while the session is loading or
- * absent, the underlying `queryFn` is replaced with `skipToken`.
- *
- * @param authClient - The Better Auth client.
- * @param options - `listSessions` params (`query`, `fetchOptions`) merged
- *   with `useQuery` options (e.g. `enabled`, `staleTime`, `select`).
- * @param queryClient - Optional custom `QueryClient`. Defaults to the client
- *   from the nearest `QueryClientProvider`.
- */
-export function useListSessions(authClient, options = {}, queryClient) {
-    const { data: session } = useSession(authClient, undefined, queryClient);
-    const userId = session?.user.id;
-    const { query, fetchOptions, ...queryOptions } = options;
-    const baseOptions = listSessionsOptions(authClient, userId, {
-        query,
-        fetchOptions
-    });
-    return useQuery({
-        ...queryOptions,
-        ...baseOptions,
-        queryFn: userId ? baseOptions.queryFn : skipToken
-    }, queryClient);
-}

package/dist/server/queries/api-key/list-api-keys-query.js

@@ -1,49 +0,0 @@
-import { apiKeyQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions } from "@tanstack/react-query";
-/**
- * Query options factory for the current user's API keys on the server.
- *
- * Uses the same query key as the client-side `listApiKeysOptions` so that data
- * fetched during SSR hydrates seamlessly into the client's React Query cache.
- *
- * @param auth - The Better Auth server instance with the API key plugin.
- * @param userId - The signed-in user's ID. Used for cache partitioning.
- * @param params - Parameters forwarded to `auth.api.listApiKeys`.
- */
-export function listApiKeysOptions(auth, userId, params) {
-    const queryKey = apiKeyQueryKeys.list(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: () => auth.api.listApiKeys(params)
-    });
-    return options;
-}
-/**
- * Get the current user's API keys from the query cache, calling
- * `fetchListApiKeys` under the hood if no cached entry exists.
- *
- * @param queryClient - The React Query client used for SSR hydration.
- * @param auth - The Better Auth server instance with the API key plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `auth.api.listApiKeys`.
- */
-export const ensureListApiKeys = (queryClient, auth, userId, params) => queryClient.ensureQueryData(listApiKeysOptions(auth, userId, params));
-/**
- * Prefetch the current user's API keys into the query cache.
- *
- * @param queryClient - The React Query client used for SSR hydration.
- * @param auth - The Better Auth server instance with the API key plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `auth.api.listApiKeys`.
- */
-export const prefetchListApiKeys = (queryClient, auth, userId, params) => queryClient.prefetchQuery(listApiKeysOptions(auth, userId, params));
-/**
- * Fetch and cache the current user's API keys, resolving with the data or
- * throwing on error.
- *
- * @param queryClient - The React Query client used for SSR hydration.
- * @param auth - The Better Auth server instance with the API key plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `auth.api.listApiKeys`.
- */
-export const fetchListApiKeys = (queryClient, auth, userId, params) => queryClient.fetchQuery(listApiKeysOptions(auth, userId, params));

package/dist/server/queries/auth/session-query.js

@@ -1,51 +0,0 @@
-import { authQueryKeys } from "@better-auth-ui/core";
-import { queryOptions } from "@tanstack/react-query";
-/**
- * Query options factory for the current session on the server.
- *
- * Uses the same query key as the client-side `sessionOptions` so that data
- * fetched during SSR hydrates seamlessly into the client's React Query cache.
- *
- * @param auth - The Better Auth server instance.
- * @param params - Parameters forwarded to `auth.api.getSession` (typically
- *   includes request `headers` for cookie-based session resolution).
- */
-export function sessionOptions(auth, params) {
-    const queryKey = authQueryKeys.session;
-    const options = queryOptions({
-        queryKey,
-        queryFn: () => auth.api.getSession(params)
-    });
-    return options;
-}
-/**
- * Get the current session from the query cache, calling `fetchSession` under
- * the hood if no cached entry exists. Resolves with the session data, making
- * it suitable for reading the value directly in a server component.
- *
- * @param queryClient - The React Query client used for SSR hydration.
- * @param auth - The Better Auth server instance.
- * @param params - Parameters forwarded to `auth.api.getSession`.
- */
-export const ensureSession = (queryClient, auth, params) => queryClient.ensureQueryData(sessionOptions(auth, params));
-/**
- * Prefetch the current session into the query cache. Behaves like
- * `fetchSession`, but does not throw on error and does not return the data —
- * use this when you only need the value to be available after hydration.
- *
- * @param queryClient - The React Query client used for SSR hydration.
- * @param auth - The Better Auth server instance.
- * @param params - Parameters forwarded to `auth.api.getSession`.
- */
-export const prefetchSession = (queryClient, auth, params) => queryClient.prefetchQuery(sessionOptions(auth, params));
-/**
- * Fetch and cache the current session, resolving with the data or throwing
- * on error. If a cached entry exists and is neither invalidated nor older
- * than `staleTime`, the cached value is returned without a network call;
- * otherwise the latest data is fetched.
- *
- * @param queryClient - The React Query client used for SSR hydration.
- * @param auth - The Better Auth server instance.
- * @param params - Parameters forwarded to `auth.api.getSession`.
- */
-export const fetchSession = (queryClient, auth, params) => queryClient.fetchQuery(sessionOptions(auth, params));

package/dist/server/queries/multi-session/list-device-sessions-query.js

@@ -1,54 +0,0 @@
-import { multiSessionQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions } from "@tanstack/react-query";
-/**
- * Query options factory for the current user's device sessions.
- *
- * @param auth - The Better Auth server instance with the multi-session plugin.
- * @param userId - The signed-in user's ID. Used for cache partitioning so
- *   the key matches the client-side `listDeviceSessionsOptions` for SSR hydration.
- * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
- */
-export function listDeviceSessionsOptions(auth, userId, params) {
-    const queryKey = multiSessionQueryKeys.list(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: () => auth.api.listDeviceSessions(params)
-    });
-    return options;
-}
-/**
- * Get the current user's device sessions from the query cache, calling
- * `fetchListDeviceSessions` under the hood if no cached entry exists.
- * Resolves with the device session list, making it suitable for reading
- * directly in a server component.
- *
- * @param queryClient - The React Query client used for SSR hydration.
- * @param auth - The Better Auth server instance with the multi-session plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
- */
-export const ensureListDeviceSessions = (queryClient, auth, userId, params) => queryClient.ensureQueryData(listDeviceSessionsOptions(auth, userId, params));
-/**
- * Prefetch the current user's device sessions into the query cache. Behaves
- * like `fetchListDeviceSessions`, but does not throw on error and does not
- * return the data — use this when you only need the value to be available
- * after hydration.
- *
- * @param queryClient - The React Query client used for SSR hydration.
- * @param auth - The Better Auth server instance with the multi-session plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
- */
-export const prefetchListDeviceSessions = (queryClient, auth, userId, params) => queryClient.prefetchQuery(listDeviceSessionsOptions(auth, userId, params));
-/**
- * Fetch and cache the current user's device sessions, resolving with the
- * data or throwing on error. If a cached entry exists and is neither
- * invalidated nor older than `staleTime`, the cached value is returned
- * without a network call; otherwise the latest data is fetched.
- *
- * @param queryClient - The React Query client used for SSR hydration.
- * @param auth - The Better Auth server instance with the multi-session plugin.
- * @param userId - The signed-in user's ID, used for cache partitioning.
- * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
- */
-export const fetchListDeviceSessions = (queryClient, auth, userId, params) => queryClient.fetchQuery(listDeviceSessionsOptions(auth, userId, params));

package/dist/server/queries/organization/active-organization-query.js

@@ -1,25 +0,0 @@
-import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions } from "@tanstack/react-query";
-/**
- * Query options factory for the active organization. Shares its cache key
- * with the client-side `activeOrganizationOptions` (including any
- * `params.query` partition such as `{ organizationSlug }`) so SSR-prefetched
- * data hydrates without a refetch — even on slug-prefixed routes.
- *
- * @param auth - The Better Auth server instance.
- * @param userId - The signed-in user's ID. Used for cache partitioning so
- *   the key matches the client-side `activeOrganizationOptions` for SSR hydration.
- * @param params - Parameters forwarded to `auth.api.getFullOrganization`. Pass
- *   `{ query: { organizationSlug } }` for slug-driven prefetches.
- */
-export function activeOrganizationOptions(auth, userId, params) {
-    const queryKey = organizationQueryKeys.activeOrganization(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: () => auth.api.getFullOrganization(params)
-    });
-    return options;
-}
-export const ensureActiveOrganization = (queryClient, auth, userId, params) => queryClient.ensureQueryData(activeOrganizationOptions(auth, userId, params));
-export const prefetchActiveOrganization = (queryClient, auth, userId, params) => queryClient.prefetchQuery(activeOrganizationOptions(auth, userId, params));
-export const fetchActiveOrganization = (queryClient, auth, userId, params) => queryClient.fetchQuery(activeOrganizationOptions(auth, userId, params));

package/dist/server/queries/organization/full-organization-query.js

@@ -1,21 +0,0 @@
-import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions } from "@tanstack/react-query";
-/**
- * Query options factory for full organization details (members, invitations, etc.).
- *
- * @param auth - The Better Auth server instance.
- * @param userId - The signed-in user's ID. Used for cache partitioning so
- *   the key matches the client-side `fullOrganizationOptions` for SSR hydration.
- * @param params - Parameters forwarded to `auth.api.getFullOrganization`.
- */
-export function fullOrganizationOptions(auth, userId, params) {
-    const queryKey = organizationQueryKeys.fullDetail(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: () => auth.api.getFullOrganization(params)
-    });
-    return options;
-}
-export const ensureFullOrganization = (queryClient, auth, userId, params) => queryClient.ensureQueryData(fullOrganizationOptions(auth, userId, params));
-export const prefetchFullOrganization = (queryClient, auth, userId, params) => queryClient.prefetchQuery(fullOrganizationOptions(auth, userId, params));
-export const fetchFullOrganization = (queryClient, auth, userId, params) => queryClient.fetchQuery(fullOrganizationOptions(auth, userId, params));

package/dist/server/queries/organization/has-permission-query.js

@@ -1,23 +0,0 @@
-import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions } from "@tanstack/react-query";
-/**
- * Query options factory for organization permission checks.
- *
- * @param auth - The Better Auth server instance.
- * @param userId - The signed-in user's ID. Used for cache partitioning so
- *   the key matches the client-side `hasPermissionOptions` for SSR hydration.
- * @param params - Parameters forwarded to `auth.api.hasPermission`.
- */
-export function hasPermissionOptions(auth, userId, params) {
-    // Same logical payload as the client key (permissions ± organizationId): client
-    // strips `fetchOptions`; server keeps that shape under `body`.
-    const queryKey = organizationQueryKeys.permissions.has(userId, params?.body);
-    const options = queryOptions({
-        queryKey,
-        queryFn: () => auth.api.hasPermission(params)
-    });
-    return options;
-}
-export const ensureHasPermission = (queryClient, auth, userId, params) => queryClient.ensureQueryData(hasPermissionOptions(auth, userId, params));
-export const prefetchHasPermission = (queryClient, auth, userId, params) => queryClient.prefetchQuery(hasPermissionOptions(auth, userId, params));
-export const fetchHasPermission = (queryClient, auth, userId, params) => queryClient.fetchQuery(hasPermissionOptions(auth, userId, params));

package/dist/server/queries/organization/list-invitations-query.js

@@ -1,21 +0,0 @@
-import { organizationQueryKeys } from "@better-auth-ui/core/plugins";
-import { queryOptions } from "@tanstack/react-query";
-/**
- * Query options factory for invitations of an organization.
- *
- * @param auth - The Better Auth server instance.
- * @param userId - The signed-in user's ID. Used for cache partitioning so
- *   the key matches the client-side `listOrganizationInvitationsOptions` for SSR hydration.
- * @param params - Parameters forwarded to `auth.api.listInvitations`.
- */
-export function listOrganizationInvitationsOptions(auth, userId, params) {
-    const queryKey = organizationQueryKeys.invitations.list(userId, params?.query);
-    const options = queryOptions({
-        queryKey,
-        queryFn: () => auth.api.listInvitations(params)
-    });
-    return options;
-}
-export const ensureListOrganizationInvitations = (queryClient, auth, userId, params) => queryClient.ensureQueryData(listOrganizationInvitationsOptions(auth, userId, params));
-export const prefetchListOrganizationInvitations = (queryClient, auth, userId, params) => queryClient.prefetchQuery(listOrganizationInvitationsOptions(auth, userId, params));
-export const fetchListOrganizationInvitations = (queryClient, auth, userId, params) => queryClient.fetchQuery(listOrganizationInvitationsOptions(auth, userId, params));