@xylex-group/athena 3.1.0 → 3.3.0

package/dist/react.d.cts

@@ -1,12 +1,13 @@
 import { u as AthenaGatewayHookConfig, v as AthenaGatewayHookResult } from './types-Bltx6iL6.cjs';
 export { w as AthenaDeletePayload, x as AthenaFetchPayload, a as AthenaGatewayCallOptions, d as AthenaGatewayErrorCode, e as AthenaGatewayErrorDetails, s as AthenaGatewayResponse, y as AthenaInsertPayload, f as AthenaJsonArray, g as AthenaJsonObject, h as AthenaJsonPrimitive, i as AthenaJsonValue, j as AthenaRpcCallOptions, k as AthenaRpcFilter, l as AthenaRpcFilterOperator, m as AthenaRpcOrder, n as AthenaRpcPayload, z as AthenaUpdatePayload } from './types-Bltx6iL6.cjs';
-import { a as AthenaReadQueryClient, c as AthenaReadQueryDefinition, e as AthenaReadQueryExecutionResult, i as AthenaReadQueryFlatRow } from './model-form-BhWWsA-7.cjs';
-export { A as AthenaGatewayError, M as ModelFormAdapter, D as ModelFormDefaults, E as ModelFormNullishMode, G as ModelFormValues, T as ToModelFormDefaultsOptions, H as ToModelPayloadOptions, _ as createModelFormAdapter, a3 as isAthenaGatewayError, a6 as toModelFormDefaults, a7 as toModelPayload } from './model-form-BhWWsA-7.cjs';
+import { a as AthenaReadQueryClient, c as AthenaReadQueryDefinition, e as AthenaReadQueryExecutionResult, i as AthenaReadQueryFlatRow } from './model-form-3Gr8rkdT.cjs';
+export { A as AthenaGatewayError, M as ModelFormAdapter, D as ModelFormDefaults, E as ModelFormNullishMode, G as ModelFormValues, T as ToModelFormDefaultsOptions, H as ToModelPayloadOptions, _ as createModelFormAdapter, a3 as isAthenaGatewayError, a7 as toModelFormDefaults, a8 as toModelPayload } from './model-form-3Gr8rkdT.cjs';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { aE as AthenaAuthFetchCompatibleInput, E as AthenaAuthCallOptions, ad as AthenaAuthSessionResponse, R as AthenaAuthErrorDetails, aa as AthenaAuthResult } from './types-AOY-GLu8.cjs';
-export { D as AthenaAuthBindings, aC as AuthBindings } from './types-AOY-GLu8.cjs';
-import { ax as AthenaRequestContext, b5 as AthenaStorageFileUploadInput, bp as AthenaStorageUploadSource, bb as AthenaStorageModule, bo as AthenaStorageUploadProgressHandler, bn as AthenaStorageUploadProgress, b8 as AthenaStorageFileUploadResult, aP as AthenaStorageCallOptions, b2 as AthenaStorageFileListInput, ck as StorageListFilesResponse, cf as StorageFileMutationResponse } from './v3-client-CWfZHcKL.cjs';
+import { aE as AthenaAuthFetchCompatibleInput, E as AthenaAuthCallOptions, ad as AthenaAuthSessionResponse, R as AthenaAuthErrorDetails, aa as AthenaAuthResult, aD as AthenaAdminHasPermissionRequest } from './types-BVKpQmfY.cjs';
+export { D as AthenaAuthBindings, aC as AuthBindings } from './types-BVKpQmfY.cjs';
+import { AthenaAdminSessionLike, AthenaAdminPermissionCheckInput } from './admin.cjs';
+import { ax as AthenaRequestContext, b5 as AthenaStorageFileUploadInput, bp as AthenaStorageUploadSource, bb as AthenaStorageModule, bo as AthenaStorageUploadProgressHandler, bn as AthenaStorageUploadProgress, b8 as AthenaStorageFileUploadResult, aP as AthenaStorageCallOptions, b2 as AthenaStorageFileListInput, ck as StorageListFilesResponse, cf as StorageFileMutationResponse } from './v3-client-G1SLeHRa.cjs';
 import './types-CgCv5o6R.cjs';
 import './module-C_ab-MM1.cjs';
 
@@ -230,9 +231,9 @@ declare function createAthenaQueryClient(config?: AthenaQueryClientConfig): Athe
 declare function attachStateAdapter(client: AthenaQueryClient, adapter: AthenaStateAdapter): AthenaUnsubscribe;
 
 interface AthenaQueryClientProviderProps {
+    children: ReactNode;
     client?: AthenaQueryClient;
     config?: AthenaQueryClientConfig;
-    children: ReactNode;
 }
 declare function AthenaQueryClientProvider(props: AthenaQueryClientProviderProps): react.FunctionComponentElement<react.ProviderProps<AthenaQueryClient | null>>;
 declare function useAthenaQueryClient(): AthenaQueryClient;
@@ -354,6 +355,55 @@ type InferSessionData$1<TClient> = TClient extends {
  */
 declare function useSession<TClient extends UseSessionAuthClient>(authClient: TClient, options?: UseSessionOptions): UseSessionResult<InferSessionData$1<TClient>>;
 
+interface UseAdminPermissionOptions {
+    /**
+     * Permission set checked via `client.auth.admin.hasPermission`.
+     * Defaults to `["admin:read"]`.
+     */
+    permissions?: AthenaAdminHasPermissionRequest['permissions'];
+    permission?: AthenaAdminHasPermissionRequest['permission'];
+    /**
+     * When provided, skips the internal session fetch.
+     * Pass `null` to force a denied result without calling getSession.
+     */
+    session?: AthenaAdminSessionLike | null;
+    allowRoleBypass?: boolean;
+    enabled?: boolean;
+    fetchOptions?: AthenaAdminPermissionCheckInput['fetchOptions'];
+    requestOptions?: AthenaAdminPermissionCheckInput['requestOptions'];
+    /** Forwarded to the internal `useSession` when `session` is omitted. */
+    sessionOptions?: Omit<UseSessionOptions, 'enabled'>;
+}
+interface UseAdminPermissionResult {
+    allowed: boolean;
+    isPending: boolean;
+    error: Error | null;
+    session: AthenaAdminSessionLike | null;
+    refetch: () => Promise<boolean>;
+}
+type AdminPermissionAuthClient = UseSessionAuthClient & {
+    auth?: {
+        admin?: unknown;
+    };
+    admin?: unknown;
+};
+/**
+ * React gate for Athena admin permissions.
+ *
+ * Uses {@link hasAdminPermission} from `@xylex-group/athena/admin` with an
+ * optional local `admin` role short-circuit. When `session` is omitted, loads
+ * the current session through {@link useSession}.
+ *
+ * @example
+ * ```tsx
+ * const athena = createClient({ url, key, auth: { url: "/api/auth" } })
+ * const { allowed, isPending } = useAdminPermission(athena, {
+ *   permissions: ["admin:read"],
+ * })
+ * ```
+ */
+declare function useAdminPermission(client: AdminPermissionAuthClient | null | undefined, options?: UseAdminPermissionOptions): UseAdminPermissionResult;
+
 type SessionGetter<TSessionData extends AthenaAuthSessionResponse> = (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<TSessionData>>;
 type AthenaContextScopedClient<TSessionData extends AthenaAuthSessionResponse = AthenaAuthSessionResponse> = {
     auth: {
@@ -400,14 +450,14 @@ interface UseStorageUploadResult {
 declare function useStorageUpload(options: UseStorageUploadOptions): UseStorageUploadResult;
 
 interface UseStorageFilesOptions {
-    storage: Pick<AthenaStorageModule, 'file'>;
+    storage: Pick<AthenaStorageModule, "file">;
     input: AthenaStorageFileListInput | null | undefined;
     enabled?: boolean;
     callOptions?: AthenaStorageCallOptions;
     refreshIntervalMs?: number;
 }
 interface UseStorageFilesResult {
-    files: StorageListFilesResponse['files'];
+    files: StorageListFilesResponse["files"];
     count: number;
     loading: boolean;
     error: unknown;
@@ -429,4 +479,4 @@ interface UseStorageFileDeleteResult {
 }
 declare function useStorageFileDelete(options: UseStorageFileDeleteOptions): UseStorageFileDeleteResult;
 
-export { type AthenaCacheMode, type AthenaCachePolicy, AthenaGatewayHookConfig, AthenaGatewayHookResult, type AthenaMutationDefaults, type AthenaMutationEvent, type AthenaMutationRequestLog, type AthenaMutationResultData, type AthenaMutationState, AthenaQueryClient, type AthenaQueryClientConfig, AthenaQueryClientProvider, type AthenaQueryDefaults, type AthenaQueryError, type AthenaQueryEvent, type AthenaQueryRequestLog, type AthenaQueryResult, type AthenaQueryState, type AthenaResponseLike, type AthenaRetryCount, type AthenaRetryDelay, type AthenaRuntimeBaseEvent, type AthenaRuntimeEvent, type AthenaRuntimeEventType, type AthenaStateAdapter, type AthenaUnsubscribe, type QueryKey, type QueryStatus, type UseAthenaReadQueryOptions, type UseAthenaReadQueryResult, type UseAthenaSessionClientOptions, type UseAthenaSessionClientResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseSessionAuthClient, type UseSessionOptions, type UseSessionResult, type UseStorageFileDeleteOptions, type UseStorageFileDeleteResult, type UseStorageFilesOptions, type UseStorageFilesResult, type UseStorageUploadInput, type UseStorageUploadOptions, type UseStorageUploadResult, attachStateAdapter, createAthenaQueryClient, useAthenaGateway, useAthenaQueryClient, useAthenaReadQuery, useAthenaSessionClient, useMutation, useQuery, useSession, useStorageFileDelete, useStorageFiles, useStorageUpload };
+export { type AthenaCacheMode, type AthenaCachePolicy, AthenaGatewayHookConfig, AthenaGatewayHookResult, type AthenaMutationDefaults, type AthenaMutationEvent, type AthenaMutationRequestLog, type AthenaMutationResultData, type AthenaMutationState, AthenaQueryClient, type AthenaQueryClientConfig, AthenaQueryClientProvider, type AthenaQueryDefaults, type AthenaQueryError, type AthenaQueryEvent, type AthenaQueryRequestLog, type AthenaQueryResult, type AthenaQueryState, type AthenaResponseLike, type AthenaRetryCount, type AthenaRetryDelay, type AthenaRuntimeBaseEvent, type AthenaRuntimeEvent, type AthenaRuntimeEventType, type AthenaStateAdapter, type AthenaUnsubscribe, type QueryKey, type QueryStatus, type UseAdminPermissionOptions, type UseAdminPermissionResult, type UseAthenaReadQueryOptions, type UseAthenaReadQueryResult, type UseAthenaSessionClientOptions, type UseAthenaSessionClientResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseSessionAuthClient, type UseSessionOptions, type UseSessionResult, type UseStorageFileDeleteOptions, type UseStorageFileDeleteResult, type UseStorageFilesOptions, type UseStorageFilesResult, type UseStorageUploadInput, type UseStorageUploadOptions, type UseStorageUploadResult, attachStateAdapter, createAthenaQueryClient, useAdminPermission, useAthenaGateway, useAthenaQueryClient, useAthenaReadQuery, useAthenaSessionClient, useMutation, useQuery, useSession, useStorageFileDelete, useStorageFiles, useStorageUpload };

package/dist/react.d.ts

@@ -1,12 +1,13 @@
 import { u as AthenaGatewayHookConfig, v as AthenaGatewayHookResult } from './types-Bltx6iL6.js';
 export { w as AthenaDeletePayload, x as AthenaFetchPayload, a as AthenaGatewayCallOptions, d as AthenaGatewayErrorCode, e as AthenaGatewayErrorDetails, s as AthenaGatewayResponse, y as AthenaInsertPayload, f as AthenaJsonArray, g as AthenaJsonObject, h as AthenaJsonPrimitive, i as AthenaJsonValue, j as AthenaRpcCallOptions, k as AthenaRpcFilter, l as AthenaRpcFilterOperator, m as AthenaRpcOrder, n as AthenaRpcPayload, z as AthenaUpdatePayload } from './types-Bltx6iL6.js';
-import { a as AthenaReadQueryClient, c as AthenaReadQueryDefinition, e as AthenaReadQueryExecutionResult, i as AthenaReadQueryFlatRow } from './model-form-BbdzJ9Uh.js';
-export { A as AthenaGatewayError, M as ModelFormAdapter, D as ModelFormDefaults, E as ModelFormNullishMode, G as ModelFormValues, T as ToModelFormDefaultsOptions, H as ToModelPayloadOptions, _ as createModelFormAdapter, a3 as isAthenaGatewayError, a6 as toModelFormDefaults, a7 as toModelPayload } from './model-form-BbdzJ9Uh.js';
+import { a as AthenaReadQueryClient, c as AthenaReadQueryDefinition, e as AthenaReadQueryExecutionResult, i as AthenaReadQueryFlatRow } from './model-form-CotpEL7z.js';
+export { A as AthenaGatewayError, M as ModelFormAdapter, D as ModelFormDefaults, E as ModelFormNullishMode, G as ModelFormValues, T as ToModelFormDefaultsOptions, H as ToModelPayloadOptions, _ as createModelFormAdapter, a3 as isAthenaGatewayError, a7 as toModelFormDefaults, a8 as toModelPayload } from './model-form-CotpEL7z.js';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { aE as AthenaAuthFetchCompatibleInput, E as AthenaAuthCallOptions, ad as AthenaAuthSessionResponse, R as AthenaAuthErrorDetails, aa as AthenaAuthResult } from './types-AOY-GLu8.js';
-export { D as AthenaAuthBindings, aC as AuthBindings } from './types-AOY-GLu8.js';
-import { ax as AthenaRequestContext, b5 as AthenaStorageFileUploadInput, bp as AthenaStorageUploadSource, bb as AthenaStorageModule, bo as AthenaStorageUploadProgressHandler, bn as AthenaStorageUploadProgress, b8 as AthenaStorageFileUploadResult, aP as AthenaStorageCallOptions, b2 as AthenaStorageFileListInput, ck as StorageListFilesResponse, cf as StorageFileMutationResponse } from './v3-client-DZp2NEhK.js';
+import { aE as AthenaAuthFetchCompatibleInput, E as AthenaAuthCallOptions, ad as AthenaAuthSessionResponse, R as AthenaAuthErrorDetails, aa as AthenaAuthResult, aD as AthenaAdminHasPermissionRequest } from './types-BVKpQmfY.js';
+export { D as AthenaAuthBindings, aC as AuthBindings } from './types-BVKpQmfY.js';
+import { AthenaAdminSessionLike, AthenaAdminPermissionCheckInput } from './admin.js';
+import { ax as AthenaRequestContext, b5 as AthenaStorageFileUploadInput, bp as AthenaStorageUploadSource, bb as AthenaStorageModule, bo as AthenaStorageUploadProgressHandler, bn as AthenaStorageUploadProgress, b8 as AthenaStorageFileUploadResult, aP as AthenaStorageCallOptions, b2 as AthenaStorageFileListInput, ck as StorageListFilesResponse, cf as StorageFileMutationResponse } from './v3-client-ao8BWQ8v.js';
 import './types-B75PdABb.js';
 import './module-C_ab-MM1.js';
 
@@ -230,9 +231,9 @@ declare function createAthenaQueryClient(config?: AthenaQueryClientConfig): Athe
 declare function attachStateAdapter(client: AthenaQueryClient, adapter: AthenaStateAdapter): AthenaUnsubscribe;
 
 interface AthenaQueryClientProviderProps {
+    children: ReactNode;
     client?: AthenaQueryClient;
     config?: AthenaQueryClientConfig;
-    children: ReactNode;
 }
 declare function AthenaQueryClientProvider(props: AthenaQueryClientProviderProps): react.FunctionComponentElement<react.ProviderProps<AthenaQueryClient | null>>;
 declare function useAthenaQueryClient(): AthenaQueryClient;
@@ -354,6 +355,55 @@ type InferSessionData$1<TClient> = TClient extends {
  */
 declare function useSession<TClient extends UseSessionAuthClient>(authClient: TClient, options?: UseSessionOptions): UseSessionResult<InferSessionData$1<TClient>>;
 
+interface UseAdminPermissionOptions {
+    /**
+     * Permission set checked via `client.auth.admin.hasPermission`.
+     * Defaults to `["admin:read"]`.
+     */
+    permissions?: AthenaAdminHasPermissionRequest['permissions'];
+    permission?: AthenaAdminHasPermissionRequest['permission'];
+    /**
+     * When provided, skips the internal session fetch.
+     * Pass `null` to force a denied result without calling getSession.
+     */
+    session?: AthenaAdminSessionLike | null;
+    allowRoleBypass?: boolean;
+    enabled?: boolean;
+    fetchOptions?: AthenaAdminPermissionCheckInput['fetchOptions'];
+    requestOptions?: AthenaAdminPermissionCheckInput['requestOptions'];
+    /** Forwarded to the internal `useSession` when `session` is omitted. */
+    sessionOptions?: Omit<UseSessionOptions, 'enabled'>;
+}
+interface UseAdminPermissionResult {
+    allowed: boolean;
+    isPending: boolean;
+    error: Error | null;
+    session: AthenaAdminSessionLike | null;
+    refetch: () => Promise<boolean>;
+}
+type AdminPermissionAuthClient = UseSessionAuthClient & {
+    auth?: {
+        admin?: unknown;
+    };
+    admin?: unknown;
+};
+/**
+ * React gate for Athena admin permissions.
+ *
+ * Uses {@link hasAdminPermission} from `@xylex-group/athena/admin` with an
+ * optional local `admin` role short-circuit. When `session` is omitted, loads
+ * the current session through {@link useSession}.
+ *
+ * @example
+ * ```tsx
+ * const athena = createClient({ url, key, auth: { url: "/api/auth" } })
+ * const { allowed, isPending } = useAdminPermission(athena, {
+ *   permissions: ["admin:read"],
+ * })
+ * ```
+ */
+declare function useAdminPermission(client: AdminPermissionAuthClient | null | undefined, options?: UseAdminPermissionOptions): UseAdminPermissionResult;
+
 type SessionGetter<TSessionData extends AthenaAuthSessionResponse> = (input?: AthenaAuthFetchCompatibleInput, options?: AthenaAuthCallOptions) => Promise<AthenaAuthResult<TSessionData>>;
 type AthenaContextScopedClient<TSessionData extends AthenaAuthSessionResponse = AthenaAuthSessionResponse> = {
     auth: {
@@ -400,14 +450,14 @@ interface UseStorageUploadResult {
 declare function useStorageUpload(options: UseStorageUploadOptions): UseStorageUploadResult;
 
 interface UseStorageFilesOptions {
-    storage: Pick<AthenaStorageModule, 'file'>;
+    storage: Pick<AthenaStorageModule, "file">;
     input: AthenaStorageFileListInput | null | undefined;
     enabled?: boolean;
     callOptions?: AthenaStorageCallOptions;
     refreshIntervalMs?: number;
 }
 interface UseStorageFilesResult {
-    files: StorageListFilesResponse['files'];
+    files: StorageListFilesResponse["files"];
     count: number;
     loading: boolean;
     error: unknown;
@@ -429,4 +479,4 @@ interface UseStorageFileDeleteResult {
 }
 declare function useStorageFileDelete(options: UseStorageFileDeleteOptions): UseStorageFileDeleteResult;
 
-export { type AthenaCacheMode, type AthenaCachePolicy, AthenaGatewayHookConfig, AthenaGatewayHookResult, type AthenaMutationDefaults, type AthenaMutationEvent, type AthenaMutationRequestLog, type AthenaMutationResultData, type AthenaMutationState, AthenaQueryClient, type AthenaQueryClientConfig, AthenaQueryClientProvider, type AthenaQueryDefaults, type AthenaQueryError, type AthenaQueryEvent, type AthenaQueryRequestLog, type AthenaQueryResult, type AthenaQueryState, type AthenaResponseLike, type AthenaRetryCount, type AthenaRetryDelay, type AthenaRuntimeBaseEvent, type AthenaRuntimeEvent, type AthenaRuntimeEventType, type AthenaStateAdapter, type AthenaUnsubscribe, type QueryKey, type QueryStatus, type UseAthenaReadQueryOptions, type UseAthenaReadQueryResult, type UseAthenaSessionClientOptions, type UseAthenaSessionClientResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseSessionAuthClient, type UseSessionOptions, type UseSessionResult, type UseStorageFileDeleteOptions, type UseStorageFileDeleteResult, type UseStorageFilesOptions, type UseStorageFilesResult, type UseStorageUploadInput, type UseStorageUploadOptions, type UseStorageUploadResult, attachStateAdapter, createAthenaQueryClient, useAthenaGateway, useAthenaQueryClient, useAthenaReadQuery, useAthenaSessionClient, useMutation, useQuery, useSession, useStorageFileDelete, useStorageFiles, useStorageUpload };
+export { type AthenaCacheMode, type AthenaCachePolicy, AthenaGatewayHookConfig, AthenaGatewayHookResult, type AthenaMutationDefaults, type AthenaMutationEvent, type AthenaMutationRequestLog, type AthenaMutationResultData, type AthenaMutationState, AthenaQueryClient, type AthenaQueryClientConfig, AthenaQueryClientProvider, type AthenaQueryDefaults, type AthenaQueryError, type AthenaQueryEvent, type AthenaQueryRequestLog, type AthenaQueryResult, type AthenaQueryState, type AthenaResponseLike, type AthenaRetryCount, type AthenaRetryDelay, type AthenaRuntimeBaseEvent, type AthenaRuntimeEvent, type AthenaRuntimeEventType, type AthenaStateAdapter, type AthenaUnsubscribe, type QueryKey, type QueryStatus, type UseAdminPermissionOptions, type UseAdminPermissionResult, type UseAthenaReadQueryOptions, type UseAthenaReadQueryResult, type UseAthenaSessionClientOptions, type UseAthenaSessionClientResult, type UseMutationOptions, type UseMutationResult, type UseQueryOptions, type UseQueryResult, type UseSessionAuthClient, type UseSessionOptions, type UseSessionResult, type UseStorageFileDeleteOptions, type UseStorageFileDeleteResult, type UseStorageFilesOptions, type UseStorageFilesResult, type UseStorageUploadInput, type UseStorageUploadOptions, type UseStorageUploadResult, attachStateAdapter, createAthenaQueryClient, useAdminPermission, useAthenaGateway, useAthenaQueryClient, useAthenaReadQuery, useAthenaSessionClient, useMutation, useQuery, useSession, useStorageFileDelete, useStorageFiles, useStorageUpload };

package/dist/react.js

@@ -392,7 +392,7 @@ function buildAthenaRequestHeaders(input) {
 
 // package.json
 var package_default = {
-  version: "3.1.0"
+  version: "3.3.0"
 };
 
 // src/sdk-version.ts
@@ -1043,7 +1043,8 @@ function stableSerialize(value, seen) {
   if (value === void 0) return "undefined";
   const valueType = typeof value;
   if (valueType === "string") return `"${value}"`;
-  if (valueType === "number") return Number.isFinite(value) ? String(value) : "null";
+  if (valueType === "number")
+    return Number.isFinite(value) ? String(value) : "null";
   if (valueType === "boolean") return value ? "true" : "false";
   if (valueType === "bigint") return `${String(value)}n`;
   if (valueType === "symbol") return `symbol:${String(value)}`;
@@ -1124,7 +1125,8 @@ async function runWithRetry(execute, options) {
 }
 function errorMessageFromUnknown(error) {
   if (typeof error === "string" && error.trim()) return error.trim();
-  if (error instanceof Error && error.message.trim()) return error.message.trim();
+  if (error instanceof Error && error.message.trim())
+    return error.message.trim();
   if (isRecord2(error)) {
     const messageCandidate = error.message ?? error.error;
     if (typeof messageCandidate === "string" && messageCandidate.trim()) {
@@ -1343,7 +1345,11 @@ var AthenaQueryClient = class {
     const key = this.getMutationKeyToken(mutationKey);
     const entry = this.ensureMutationEntry(key);
     entry.activeRequestId = ++this.requestCounter;
-    this.setMutationState(entry, createInitialMutationState(), "mutation_reset");
+    this.setMutationState(
+      entry,
+      createInitialMutationState(),
+      "mutation_reset"
+    );
   }
   async executeQuery(input) {
     const entry = this.ensureQueryEntry(input.queryKeyToken);
@@ -1405,7 +1411,10 @@ var AthenaQueryClient = class {
           );
         }
         const rawResult = await input.queryFn();
-        const normalized = normalizeAthenaResult(rawResult, input.select);
+        const normalized = normalizeAthenaResult(
+          rawResult,
+          input.select
+        );
         if (normalized.error) {
           throw {
             __athenaNormalizedError: normalized.error,
@@ -1493,7 +1502,10 @@ var AthenaQueryClient = class {
         this.inflightQueries.delete(input.queryKeyToken);
       }
     });
-    this.inflightQueries.set(input.queryKeyToken, executionPromise);
+    this.inflightQueries.set(
+      input.queryKeyToken,
+      executionPromise
+    );
     return executionPromise;
   }
   async executeMutation(input) {
@@ -1539,7 +1551,10 @@ var AthenaQueryClient = class {
             );
           }
           const rawResult = await input.mutationFn(input.variables);
-          const normalized = normalizeAthenaResult(rawResult, input.select);
+          const normalized = normalizeAthenaResult(
+            rawResult,
+            input.select
+          );
           if (normalized.error) {
             throw {
               __athenaNormalizedError: normalized.error,
@@ -2164,12 +2179,6 @@ function applyAthenaReadQuerySelectOrder(queryBuilder, orderBy) {
     queryBuilder
   );
 }
-function applyAthenaReadQuerySelectLimit(queryBuilder, limit) {
-  if (!limit || limit < 1) {
-    return queryBuilder;
-  }
-  return queryBuilder.limit(limit);
-}
 function clampAthenaReadQueryTotalItems(totalItems, limit) {
   if (!limit || limit < 1) {
     return totalItems;
@@ -2202,6 +2211,27 @@ function resolveTotalItemsFromPage({
   }
   return clampAthenaReadQueryTotalItems(exactCount, limit);
 }
+function resolveAthenaReadQueryPageFetch({
+  page,
+  pageSize,
+  limit
+}) {
+  const safePage = Math.max(1, Math.trunc(page) || 1);
+  const safePageSize = Math.max(1, Math.trunc(pageSize) || 1);
+  if (!limit || limit < 1) {
+    return { page: safePage, pageSize: safePageSize, shouldFetch: true };
+  }
+  const totalCap = Math.trunc(limit);
+  const offset = (safePage - 1) * safePageSize;
+  if (offset >= totalCap) {
+    return { page: safePage, pageSize: safePageSize, shouldFetch: false };
+  }
+  return {
+    page: safePage,
+    pageSize: Math.min(safePageSize, totalCap - offset),
+    shouldFetch: true
+  };
+}
 async function executeAthenaReadQuery({
   client,
   page,
@@ -2220,15 +2250,29 @@ async function executeAthenaReadQuery({
     count: "exact",
     head: true
   });
+  const pageFetch = resolveAthenaReadQueryPageFetch({
+    limit: query.limit,
+    page,
+    pageSize
+  });
+  if (!pageFetch.shouldFetch) {
+    return {
+      rows: [],
+      totalItems: resolveTotalItemsFromPage({
+        countCandidates: [countResult.count],
+        limit: query.limit,
+        page: pageFetch.page,
+        pageSize,
+        rowCount: 0
+      })
+    };
+  }
   if ((query.mode ?? "findMany") === "select") {
-    const selectBuilder = applyAthenaReadQuerySelectLimit(
-      applyAthenaReadQuerySelectOrder(
-        applyAthenaReadQueryFilters(baseBuilder, query.filters),
-        query.orderBy
-      ),
-      query.limit
+    const selectBuilder = applyAthenaReadQuerySelectOrder(
+      applyAthenaReadQueryFilters(baseBuilder, query.filters),
+      query.orderBy
     );
-    const result2 = await selectBuilder.currentPage(page).pageSize(pageSize).select(buildAthenaReadQuerySelectString(query.columns), {
+    const result2 = await selectBuilder.currentPage(pageFetch.page).pageSize(pageFetch.pageSize).select(buildAthenaReadQuerySelectString(query.columns), {
       count: "exact"
     });
     const rows2 = flattenAthenaReadQueryRows(
@@ -2242,7 +2286,7 @@ async function executeAthenaReadQuery({
       totalItems: resolveTotalItemsFromPage({
         countCandidates: [countResult.count, result2.count],
         limit: query.limit,
-        page,
+        page: pageFetch.page,
         pageSize,
         rowCount: rows2.length
       })
@@ -2250,12 +2294,11 @@ async function executeAthenaReadQuery({
   }
   const findManyOrderBy = buildAthenaReadQueryFindManyOrderBy(query.orderBy);
   const findManyOptions = {
-    ...query.limit ? { limit: query.limit } : {},
     ...findManyOrderBy ? { orderBy: findManyOrderBy } : {},
     select: buildAthenaReadQueryFindManySelect(query.columns),
     ...query.filters?.length ? { where: buildAthenaReadQueryFindManyWhere(query.filters) } : {}
   };
-  const result = await baseBuilder.currentPage(page).pageSize(pageSize).findMany(findManyOptions);
+  const result = await baseBuilder.currentPage(pageFetch.page).pageSize(pageFetch.pageSize).findMany(findManyOptions);
   const rows = flattenAthenaReadQueryRows(
     Array.isArray(result.data) ? result.data : [],
     query.columns,
@@ -2267,7 +2310,7 @@ async function executeAthenaReadQuery({
     totalItems: resolveTotalItemsFromPage({
       countCandidates: [countResult.count, result.count],
       limit: query.limit,
-      page,
+      page: pageFetch.page,
       pageSize,
       rowCount: rows.length
     })
@@ -2379,7 +2422,16 @@ function resolveGetSession(authClient) {
   if ("auth" in authClient && authClient.auth && typeof authClient.auth.getSession === "function") {
     return authClient.auth.getSession;
   }
-  throw new Error("useSession requires an auth-capable client (createClient(...).auth)");
+  throw new Error(
+    "useSession requires an auth-capable client (createClient(...).auth)"
+  );
+}
+function toFallbackErrorDetails(code, message, status) {
+  return {
+    code,
+    message,
+    status
+  };
 }
 function useSession(authClient, options = {}) {
   const enabled = options.enabled ?? true;
@@ -2397,11 +2449,6 @@ function useSession(authClient, options = {}) {
   useEffect(() => {
     dataRef.current = data;
   }, [data]);
-  const toFallbackErrorDetails = (code, message, status) => ({
-    code,
-    message,
-    status
-  });
   const runFetch = useCallback(async () => {
     const requestId = ++requestIdRef.current;
     const hasData = dataRef.current !== null;
@@ -2464,6 +2511,211 @@ function useSession(authClient, options = {}) {
     refetch
   };
 }
+
+// src/admin/index.ts
+function resolveAdminPermissionClient(client) {
+  if (!client || typeof client !== "object") {
+    return null;
+  }
+  const record = client;
+  const nestedAuth = record.auth;
+  if (nestedAuth && typeof nestedAuth === "object" && nestedAuth !== null && "admin" in nestedAuth) {
+    return client;
+  }
+  if ("admin" in record) {
+    return { auth: client };
+  }
+  return null;
+}
+function buildAdminAuthFetchOptions(credentials = {}) {
+  const cookie = credentials.cookie?.trim() || void 0;
+  const bearerToken = credentials.bearerToken?.trim() || void 0;
+  const headers = {};
+  if (cookie) {
+    headers.cookie = cookie;
+  }
+  if (bearerToken) {
+    headers.authorization = `Bearer ${bearerToken}`;
+  }
+  return {
+    credentials: "include",
+    ...bearerToken ? { bearerToken } : {},
+    ...Object.keys(headers).length > 0 ? { headers } : {}
+  };
+}
+function hasAdminRole(session) {
+  const role = session?.user?.role;
+  if (!role) {
+    return false;
+  }
+  return role.split(",").map((item) => item.trim().toLowerCase()).includes("admin");
+}
+function mergeAdminFetchOptions(input) {
+  const fromCredentials = input.credentials ? buildAdminAuthFetchOptions(input.credentials) : void 0;
+  const explicit = input.fetchOptions;
+  if (!fromCredentials && !explicit) {
+    return void 0;
+  }
+  if (!fromCredentials) {
+    return explicit;
+  }
+  if (!explicit) {
+    return fromCredentials;
+  }
+  return {
+    ...fromCredentials,
+    ...explicit,
+    headers: {
+      ...fromCredentials.headers ?? {},
+      ...explicit.headers ?? {}
+    }
+  };
+}
+async function hasAdminPermission(client, input) {
+  if (!input.session?.user?.id) {
+    return false;
+  }
+  if (input.allowRoleBypass !== false && hasAdminRole(input.session)) {
+    return true;
+  }
+  const fetchOptions = mergeAdminFetchOptions(input);
+  const result = await client.auth.admin.hasPermission(
+    {
+      permission: input.permission,
+      permissions: input.permissions,
+      ...fetchOptions ? { fetchOptions } : {}
+    },
+    input.requestOptions
+  );
+  return Boolean(result.ok && result.data?.success);
+}
+
+// src/react/use-admin-permission.ts
+var DEFAULT_ADMIN_PERMISSIONS = [
+  "admin:read"
+];
+function serializePermissions(permissions, permission) {
+  return JSON.stringify({
+    permission: permission ?? null,
+    permissions: permissions ?? DEFAULT_ADMIN_PERMISSIONS
+  });
+}
+function useAdminPermission(client, options = {}) {
+  const enabled = options.enabled ?? true;
+  const sessionProvided = "session" in options;
+  const sessionFromOptions = sessionProvided ? options.session ?? null : void 0;
+  const permissionsKey = serializePermissions(options.permissions, options.permission);
+  const allowRoleBypass = options.allowRoleBypass;
+  const fetchOptions = options.fetchOptions;
+  const requestOptions = options.requestOptions;
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const sessionState = useSession(client, {
+    ...options.sessionOptions,
+    enabled: enabled && !sessionProvided && !!client
+  });
+  const session = sessionProvided ? sessionFromOptions ?? null : sessionState.data;
+  const sessionPending = !sessionProvided && sessionState.isPending;
+  const sessionUserId = session?.user?.id ?? null;
+  const sessionRole = session?.user?.role ?? null;
+  const [allowed, setAllowed] = useState(false);
+  const [error, setError] = useState(null);
+  const [isChecking, setIsChecking] = useState(enabled);
+  const requestIdRef = useRef(0);
+  const mountedRef = useRef(true);
+  const runCheck = useCallback(async () => {
+    const requestId = ++requestIdRef.current;
+    const current = optionsRef.current;
+    const permissions = current.permissions ?? DEFAULT_ADMIN_PERMISSIONS;
+    if (!enabled || !client) {
+      if (mountedRef.current && requestId === requestIdRef.current) {
+        setAllowed(false);
+        setError(null);
+        setIsChecking(false);
+      }
+      return false;
+    }
+    setIsChecking(true);
+    try {
+      const permissionClient = resolveAdminPermissionClient(client);
+      if (!permissionClient) {
+        throw new Error(
+          "useAdminPermission requires an Athena client with auth.admin (createClient(...) or auth bindings)"
+        );
+      }
+      const resolvedSession = sessionProvided ? current.session ?? null : sessionState.data;
+      const nextAllowed = await hasAdminPermission(permissionClient, {
+        session: resolvedSession,
+        permissions,
+        permission: current.permission,
+        allowRoleBypass: current.allowRoleBypass,
+        fetchOptions: current.fetchOptions,
+        requestOptions: current.requestOptions
+      });
+      if (!mountedRef.current || requestId !== requestIdRef.current) {
+        return nextAllowed;
+      }
+      setAllowed(nextAllowed);
+      setError(null);
+      return nextAllowed;
+    } catch (checkError) {
+      if (!mountedRef.current || requestId !== requestIdRef.current) {
+        return false;
+      }
+      const nextError = checkError instanceof Error ? checkError : new Error("Failed to resolve admin permission");
+      setAllowed(false);
+      setError(nextError);
+      return false;
+    } finally {
+      if (mountedRef.current && requestId === requestIdRef.current) {
+        setIsChecking(false);
+      }
+    }
+  }, [client, enabled, sessionProvided, sessionState.data]);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  useEffect(() => {
+    if (!enabled) {
+      setAllowed(false);
+      setError(null);
+      setIsChecking(false);
+      return;
+    }
+    if (!sessionProvided && sessionState.isPending) {
+      setIsChecking(true);
+      return;
+    }
+    void runCheck();
+  }, [
+    allowRoleBypass,
+    enabled,
+    fetchOptions,
+    permissionsKey,
+    requestOptions,
+    runCheck,
+    sessionPending,
+    sessionProvided,
+    sessionRole,
+    sessionUserId
+  ]);
+  const refetch = useCallback(async () => {
+    if (!sessionProvided) {
+      await sessionState.refetch();
+    }
+    return await runCheck();
+  }, [runCheck, sessionProvided, sessionState]);
+  return {
+    allowed,
+    isPending: enabled && (sessionPending || isChecking),
+    error,
+    session,
+    refetch
+  };
+}
 function useAthenaSessionClient(baseClient, options = {}) {
   const sessionState = useSession(baseClient, options);
   const scopedClient = useMemo(
@@ -2568,7 +2820,13 @@ function isStorageUploadInput(input) {
   return Boolean(input) && typeof input === "object" && "files" in input && "s3_id" in input;
 }
 function useStorageFiles(options) {
-  const { storage, input, enabled = true, callOptions, refreshIntervalMs } = options;
+  const {
+    storage,
+    input,
+    enabled = true,
+    callOptions,
+    refreshIntervalMs
+  } = options;
   const [data, setData] = React.useState(null);
   const [loading, setLoading] = React.useState(false);
   const [error, setError] = React.useState(null);
@@ -2721,6 +2979,6 @@ function createModelFormAdapter(model) {
   };
 }
 
-export { AthenaGatewayError, AthenaQueryClient, AthenaQueryClientProvider, attachStateAdapter, createAthenaQueryClient, createModelFormAdapter, isAthenaGatewayError, toModelFormDefaults, toModelPayload, useAthenaGateway, useAthenaQueryClient, useAthenaReadQuery, useAthenaSessionClient, useMutation, useQuery, useSession, useStorageFileDelete, useStorageFiles, useStorageUpload };
+export { AthenaGatewayError, AthenaQueryClient, AthenaQueryClientProvider, attachStateAdapter, createAthenaQueryClient, createModelFormAdapter, isAthenaGatewayError, toModelFormDefaults, toModelPayload, useAdminPermission, useAthenaGateway, useAthenaQueryClient, useAthenaReadQuery, useAthenaSessionClient, useMutation, useQuery, useSession, useStorageFileDelete, useStorageFiles, useStorageUpload };
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map