@better-auth-ui/react 1.6.7 → 1.6.9

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

@@ -0,0 +1,49 @@
+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.d.ts

@@ -1,6 +1,6 @@
-import { DataTag, QueryClient } from '@tanstack/react-query';
-import { APIError } from 'better-auth';
-import { AuthServer } from '../../../lib/auth-server';
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { APIError } from "better-auth";
+import type { AuthServer } from "../../../lib/auth-server";
 export type SessionData<TAuth extends AuthServer = AuthServer> = Awaited<ReturnType<TAuth["api"]["getSession"]>>;
 export type Session<TAuth extends AuthServer = AuthServer> = NonNullable<SessionData<TAuth>>;
 export type SessionParams<TAuth extends AuthServer> = Parameters<TAuth["api"]["getSession"]>[0];
@@ -14,8 +14,8 @@ export type SessionParams<TAuth extends AuthServer> = Parameters<TAuth["api"]["g
  * @param params - Parameters forwarded to `auth.api.getSession` (typically
  *   includes request `headers` for cookie-based session resolution).
  */
-export declare function sessionOptions<TAuth extends AuthServer>(auth: TAuth, params: SessionParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["getSession"]>>, APIError, Awaited<ReturnType<TAuth["api"]["getSession"]>>, readonly ["auth", "getSession"]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["getSession"]>>, readonly ["auth", "getSession"], never> | undefined;
+export declare function sessionOptions<TAuth extends AuthServer>(auth: TAuth, params: SessionParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["getSession"]>>, APIError, Awaited<ReturnType<TAuth["api"]["getSession"]>>, readonly ["auth", "getSession"]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["getSession"]>>, readonly ["auth", "getSession"], never> | undefined;
 } & {
     queryKey: readonly ["auth", "getSession"] & {
         [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["getSession"]>>;

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

@@ -1,13 +1,51 @@
-import { authQueryKeys as e } from "@better-auth-ui/core";
-import { queryOptions as t } from "@tanstack/react-query";
-//#region src/server/queries/auth/session-query.ts
-function n(n, r) {
-	let i = e.session;
-	return t({
-		queryKey: i,
-		queryFn: () => n.api.getSession(r)
-	});
+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;
 }
-var r = (e, t, r) => e.ensureQueryData(n(t, r)), i = (e, t, r) => e.prefetchQuery(n(t, r)), a = (e, t, r) => e.fetchQuery(n(t, r));
-//#endregion
-export { r as ensureSession, a as fetchSession, i as prefetchSession, n as sessionOptions };
+/**
+ * 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.d.ts

@@ -1,6 +1,6 @@
-import { DataTag, QueryClient } from '@tanstack/react-query';
-import { APIError } from 'better-auth';
-import { MultiSessionAuthServer } from '../../../lib/auth-server';
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { APIError } from "better-auth";
+import type { MultiSessionAuthServer } from "../../../lib/auth-server";
 export type ListDeviceSessionsData<TAuth extends MultiSessionAuthServer> = Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>;
 export type ListDeviceSession<TAuth extends MultiSessionAuthServer = MultiSessionAuthServer> = NonNullable<ListDeviceSessionsData<TAuth>>[number];
 export type ListDeviceSessionsParams<TAuth extends MultiSessionAuthServer> = Parameters<TAuth["api"]["listDeviceSessions"]>[0];
@@ -12,15 +12,15 @@ export type ListDeviceSessionsParams<TAuth extends MultiSessionAuthServer> = Par
  *   the key matches the client-side `listDeviceSessionsOptions` for SSR hydration.
  * @param params - Parameters forwarded to `auth.api.listDeviceSessions`.
  */
-export declare function listDeviceSessionsOptions<TAuth extends MultiSessionAuthServer>(auth: TAuth, userId: string, params: ListDeviceSessionsParams<TAuth>): (import('@tanstack/react-query').OmitKeyof<import('@tanstack/react-query').UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null]>, "queryFn"> & {
-    queryFn?: import('@tanstack/react-query').QueryFunction<Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null], never> | undefined;
+export declare function listDeviceSessionsOptions<TAuth extends MultiSessionAuthServer>(auth: TAuth, userId: string, params: ListDeviceSessionsParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null], never> | undefined;
 } & {
-    queryKey: readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null] & {
+    queryKey: readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null] & {
         [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>;
         [dataTagErrorSymbol]: APIError;
     };
 }) & {
-    queryKey: DataTag<readonly ["auth", "user", string | undefined, "listDeviceSessions", Record<string, any> | null], Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, APIError>;
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "multiSession", "list", Record<string, any> | null], Awaited<ReturnType<TAuth["api"]["listDeviceSessions"]>>, APIError>;
 };
 /**
  * Get the current user's device sessions from the query cache, calling

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

@@ -1,12 +1,54 @@
-import { authQueryKeys as e } from "@better-auth-ui/core";
-import { queryOptions as t } from "@tanstack/react-query";
-//#region src/server/queries/multi-session/list-device-sessions-query.ts
-function n(n, r, i) {
-	return t({
-		queryKey: e.listDeviceSessions(r, i?.query),
-		queryFn: () => n.api.listDeviceSessions(i)
-	});
+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;
 }
-var r = (e, t, r, i) => e.ensureQueryData(n(t, r, i)), i = (e, t, r, i) => e.prefetchQuery(n(t, r, i)), a = (e, t, r, i) => e.fetchQuery(n(t, r, i));
-//#endregion
-export { r as ensureListDeviceSessions, a as fetchListDeviceSessions, n as listDeviceSessionsOptions, i as prefetchListDeviceSessions };
+/**
+ * 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.d.ts

@@ -0,0 +1,61 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { APIError } from "better-auth";
+import type { OrganizationAuthServer } from "../../../lib/auth-server";
+import type { FullOrganizationParams } from "./full-organization-query";
+import type { ListOrganization } from "./list-organizations-query";
+/**
+ * Cache shape for the active organization. Intentionally narrowed to
+ * {@link ListOrganization} (basic fields only) so the cache stays
+ * compatible with `setActive`'s optimistic update, which can only produce
+ * list-shaped data. Use {@link FullOrganizationData} (via
+ * `fullOrganizationOptions`) when you need members / invitations.
+ */
+export type ActiveOrganizationData<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = ListOrganization<TAuth>;
+/**
+ * Same shape as {@link FullOrganizationParams} so server-side prefetches
+ * can target a specific organization (e.g. by `query.organizationSlug` for
+ * slug-driven routes) and produce a cache key that matches the client's
+ * `useActiveOrganization({ query: { organizationSlug } })` on hydration.
+ */
+export type ActiveOrganizationParams<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = FullOrganizationParams<TAuth>;
+/**
+ * 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 declare function activeOrganizationOptions<TAuth extends OrganizationAuthServer>(auth: TAuth, userId: string, params: ActiveOrganizationParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<ActiveOrganizationData<TAuth>, APIError, ActiveOrganizationData<TAuth>, readonly ["auth", "user", string | undefined, "organization", "active", {
+    organizationId?: string | undefined;
+    organizationSlug?: string | undefined;
+    membersLimit?: string | number | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<ActiveOrganizationData<TAuth>, readonly ["auth", "user", string | undefined, "organization", "active", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "active", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null] & {
+        [dataTagSymbol]: ActiveOrganizationData<TAuth>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "active", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null], ActiveOrganizationData<TAuth>, APIError>;
+};
+export declare const ensureActiveOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ActiveOrganizationParams<TAuth>) => Promise<ActiveOrganizationData<TAuth>>;
+export declare const prefetchActiveOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ActiveOrganizationParams<TAuth>) => Promise<void>;
+export declare const fetchActiveOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ActiveOrganizationParams<TAuth>) => Promise<ActiveOrganizationData<TAuth>>;

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

@@ -0,0 +1,25 @@
+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.d.ts

@@ -0,0 +1,42 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { APIError } from "better-auth";
+import type { OrganizationAuthServer } from "../../../lib/auth-server";
+export type FullOrganizationData<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>;
+export type FullOrganizationParams<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Parameters<TAuth["api"]["getFullOrganization"]>[0];
+/**
+ * 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 declare function fullOrganizationOptions<TAuth extends OrganizationAuthServer>(auth: TAuth, userId: string, params: FullOrganizationParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>, APIError, Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>, readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+    organizationId?: string | undefined;
+    organizationSlug?: string | undefined;
+    membersLimit?: string | number | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>, readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "fullDetails", {
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+        membersLimit?: string | number | undefined;
+    } | null], Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>, APIError>;
+};
+export declare const ensureFullOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: FullOrganizationParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>>;
+export declare const prefetchFullOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: FullOrganizationParams<TAuth>) => Promise<void>;
+export declare const fetchFullOrganization: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: FullOrganizationParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["getFullOrganization"]>>>;

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

@@ -0,0 +1,21 @@
+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.d.ts

@@ -0,0 +1,66 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { APIError } from "better-auth";
+import type { OrganizationAuthServer } from "../../../lib/auth-server";
+export type HasPermissionData<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Awaited<ReturnType<TAuth["api"]["hasPermission"]>>;
+export type HasPermissionParams<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Parameters<TAuth["api"]["hasPermission"]>[0];
+/**
+ * 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 declare function hasPermissionOptions<TAuth extends OrganizationAuthServer>(auth: TAuth, userId: string, params: HasPermissionParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["hasPermission"]>>, APIError, Awaited<ReturnType<TAuth["api"]["hasPermission"]>>, readonly ["auth", "user", string | undefined, "organization", "permissions", "has", NonNullable<{
+    permissions: {
+        readonly organization?: ("update" | "delete")[] | undefined;
+        readonly member?: ("update" | "delete" | "create")[] | undefined;
+        readonly invitation?: ("create" | "cancel")[] | undefined;
+        readonly team?: ("update" | "delete" | "create")[] | undefined;
+        readonly ac?: ("update" | "delete" | "create" | "read")[] | undefined;
+    };
+} & {
+    organizationId?: string | undefined;
+}> | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["hasPermission"]>>, readonly ["auth", "user", string | undefined, "organization", "permissions", "has", NonNullable<{
+        permissions: {
+            readonly organization?: ("update" | "delete")[] | undefined;
+            readonly member?: ("update" | "delete" | "create")[] | undefined;
+            readonly invitation?: ("create" | "cancel")[] | undefined;
+            readonly team?: ("update" | "delete" | "create")[] | undefined;
+            readonly ac?: ("update" | "delete" | "create" | "read")[] | undefined;
+        };
+    } & {
+        organizationId?: string | undefined;
+    }> | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "permissions", "has", NonNullable<{
+        permissions: {
+            readonly organization?: ("update" | "delete")[] | undefined;
+            readonly member?: ("update" | "delete" | "create")[] | undefined;
+            readonly invitation?: ("create" | "cancel")[] | undefined;
+            readonly team?: ("update" | "delete" | "create")[] | undefined;
+            readonly ac?: ("update" | "delete" | "create" | "read")[] | undefined;
+        };
+    } & {
+        organizationId?: string | undefined;
+    }> | null] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["hasPermission"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "permissions", "has", NonNullable<{
+        permissions: {
+            readonly organization?: ("update" | "delete")[] | undefined;
+            readonly member?: ("update" | "delete" | "create")[] | undefined;
+            readonly invitation?: ("create" | "cancel")[] | undefined;
+            readonly team?: ("update" | "delete" | "create")[] | undefined;
+            readonly ac?: ("update" | "delete" | "create" | "read")[] | undefined;
+        };
+    } & {
+        organizationId?: string | undefined;
+    }> | null], Awaited<ReturnType<TAuth["api"]["hasPermission"]>>, APIError>;
+};
+export declare const ensureHasPermission: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: HasPermissionParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["hasPermission"]>>>;
+export declare const prefetchHasPermission: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: HasPermissionParams<TAuth>) => Promise<void>;
+export declare const fetchHasPermission: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: HasPermissionParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["hasPermission"]>>>;

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

@@ -0,0 +1,23 @@
+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.d.ts

@@ -0,0 +1,34 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { APIError } from "better-auth";
+import type { OrganizationAuthServer } from "../../../lib/auth-server";
+export type ListOrganizationInvitationsData<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Awaited<ReturnType<TAuth["api"]["listInvitations"]>>;
+export type ListOrganizationInvitationsParams<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Parameters<TAuth["api"]["listInvitations"]>[0];
+/**
+ * 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 declare function listOrganizationInvitationsOptions<TAuth extends OrganizationAuthServer>(auth: TAuth, userId: string, params: ListOrganizationInvitationsParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listInvitations"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listInvitations"]>>, readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
+    organizationId?: string | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["listInvitations"]>>, readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
+        organizationId?: string | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
+        organizationId?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listInvitations"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "invitations", "list", {
+        organizationId?: string | undefined;
+    } | null], Awaited<ReturnType<TAuth["api"]["listInvitations"]>>, APIError>;
+};
+export declare const ensureListOrganizationInvitations: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListOrganizationInvitationsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listInvitations"]>>>;
+export declare const prefetchListOrganizationInvitations: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListOrganizationInvitationsParams<TAuth>) => Promise<void>;
+export declare const fetchListOrganizationInvitations: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListOrganizationInvitationsParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listInvitations"]>>>;

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

@@ -0,0 +1,21 @@
+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));

package/dist/server/queries/organization/list-members-query.d.ts

@@ -0,0 +1,66 @@
+import { type DataTag, type QueryClient } from "@tanstack/react-query";
+import type { APIError } from "better-auth";
+import type { OrganizationAuthServer } from "../../../lib/auth-server";
+export type ListOrganizationMembersData<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Awaited<ReturnType<TAuth["api"]["listMembers"]>>;
+export type ListOrganizationMembersParams<TAuth extends OrganizationAuthServer = OrganizationAuthServer> = Parameters<TAuth["api"]["listMembers"]>[0];
+/**
+ * Query options factory for members 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 `listOrganizationMembersOptions` for SSR hydration.
+ * @param params - Parameters forwarded to `auth.api.listMembers`.
+ */
+export declare function listOrganizationMembersOptions<TAuth extends OrganizationAuthServer>(auth: TAuth, userId: string, params: ListOrganizationMembersParams<TAuth>): (import("@tanstack/react-query").OmitKeyof<import("@tanstack/react-query").UseQueryOptions<Awaited<ReturnType<TAuth["api"]["listMembers"]>>, APIError, Awaited<ReturnType<TAuth["api"]["listMembers"]>>, readonly ["auth", "user", string | undefined, "organization", "members", "list", {
+    limit?: string | number | undefined;
+    offset?: string | number | undefined;
+    sortBy?: string | undefined;
+    sortDirection?: "asc" | "desc" | undefined;
+    filterField?: string | undefined;
+    filterValue?: string | number | boolean | string[] | number[] | undefined;
+    filterOperator?: "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+    organizationId?: string | undefined;
+    organizationSlug?: string | undefined;
+} | null]>, "queryFn"> & {
+    queryFn?: import("@tanstack/react-query").QueryFunction<Awaited<ReturnType<TAuth["api"]["listMembers"]>>, readonly ["auth", "user", string | undefined, "organization", "members", "list", {
+        limit?: string | number | undefined;
+        offset?: string | number | undefined;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+        filterField?: string | undefined;
+        filterValue?: string | number | boolean | string[] | number[] | undefined;
+        filterOperator?: "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+    } | null], never> | undefined;
+} & {
+    queryKey: readonly ["auth", "user", string | undefined, "organization", "members", "list", {
+        limit?: string | number | undefined;
+        offset?: string | number | undefined;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+        filterField?: string | undefined;
+        filterValue?: string | number | boolean | string[] | number[] | undefined;
+        filterOperator?: "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+    } | null] & {
+        [dataTagSymbol]: Awaited<ReturnType<TAuth["api"]["listMembers"]>>;
+        [dataTagErrorSymbol]: APIError;
+    };
+}) & {
+    queryKey: DataTag<readonly ["auth", "user", string | undefined, "organization", "members", "list", {
+        limit?: string | number | undefined;
+        offset?: string | number | undefined;
+        sortBy?: string | undefined;
+        sortDirection?: "asc" | "desc" | undefined;
+        filterField?: string | undefined;
+        filterValue?: string | number | boolean | string[] | number[] | undefined;
+        filterOperator?: "in" | "eq" | "ne" | "gt" | "gte" | "lt" | "lte" | "not_in" | "contains" | "starts_with" | "ends_with" | undefined;
+        organizationId?: string | undefined;
+        organizationSlug?: string | undefined;
+    } | null], Awaited<ReturnType<TAuth["api"]["listMembers"]>>, APIError>;
+};
+export declare const ensureListOrganizationMembers: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListOrganizationMembersParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listMembers"]>>>;
+export declare const prefetchListOrganizationMembers: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListOrganizationMembersParams<TAuth>) => Promise<void>;
+export declare const fetchListOrganizationMembers: <TAuth extends OrganizationAuthServer>(queryClient: QueryClient, auth: TAuth, userId: string, params: ListOrganizationMembersParams<TAuth>) => Promise<Awaited<ReturnType<TAuth["api"]["listMembers"]>>>;