@xylex-group/athena 3.0.3 → 3.3.0

package/dist/react.cjs

@@ -413,7 +413,7 @@ function buildAthenaRequestHeaders(input) {
 
 // package.json
 var package_default = {
-  version: "3.0.3"
+  version: "3.3.0"
 };
 
 // src/sdk-version.ts
@@ -1064,7 +1064,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)}`;
@@ -1145,7 +1146,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()) {
@@ -1364,7 +1366,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);
@@ -1426,7 +1432,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,
@@ -1514,7 +1523,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) {
@@ -1560,7 +1572,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,
@@ -1997,6 +2012,430 @@ function useMutation(options) {
     lastRequest: snapshot.lastRequest
   };
 }
+
+// src/query-debug-ast.ts
+var ATHENA_DEBUG_AST_KEY = "__athenaDebugAst";
+function getAthenaDebugAst(value) {
+  if (!value || typeof value !== "object" && typeof value !== "function") {
+    return null;
+  }
+  return value[ATHENA_DEBUG_AST_KEY] ?? null;
+}
+
+// src/query/read-query.ts
+function normalizeAthenaReadQueryOrderBy(orderBy) {
+  if (!orderBy) {
+    return [];
+  }
+  const list = Array.isArray(orderBy) ? orderBy : [orderBy];
+  return list.filter(
+    (entry) => entry && typeof entry.column === "string" && entry.column.trim().length > 0
+  );
+}
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function flattenAthenaRowValue(row, column) {
+  if (!column.relation) {
+    return row[column.column];
+  }
+  const relationValue = row[column.relation.name];
+  if (Array.isArray(relationValue)) {
+    return relationValue.map((entry) => isRecord3(entry) ? entry[column.column] : void 0).filter((entry) => entry !== void 0);
+  }
+  if (isRecord3(relationValue)) {
+    return relationValue[column.column];
+  }
+  return void 0;
+}
+function resolveFlatRowKey(row, index, preferredKey) {
+  const preferredValue = preferredKey && preferredKey in row ? row[preferredKey] : void 0;
+  if (preferredValue !== void 0 && preferredValue !== null && `${preferredValue}`.trim().length > 0) {
+    return String(preferredValue);
+  }
+  for (const [key, value] of Object.entries(row)) {
+    if (key === "__rowKey") {
+      continue;
+    }
+    if (value === void 0 || value === null) {
+      continue;
+    }
+    if (Array.isArray(value)) {
+      if (value.length > 0) {
+        return `${key}-${value.join("-")}`;
+      }
+      continue;
+    }
+    const nextValue = String(value).trim();
+    if (nextValue.length > 0) {
+      return nextValue;
+    }
+  }
+  return `row-${index + 1}`;
+}
+function flattenAthenaReadQueryRows(rows, columns, preferredKey) {
+  return rows.map((entry, index) => {
+    const sourceRow = isRecord3(entry) ? entry : {};
+    const flatRow = columns.reduce(
+      (currentRow, column) => {
+        currentRow[column.key] = flattenAthenaRowValue(sourceRow, column);
+        return currentRow;
+      },
+      { __rowKey: "" }
+    );
+    flatRow.__rowKey = resolveFlatRowKey(flatRow, index, preferredKey);
+    return flatRow;
+  });
+}
+function buildAthenaReadQuerySelectString(columns) {
+  const baseColumns = columns.filter((column) => !column.relation).map((column) => column.column);
+  const relationGroups = /* @__PURE__ */ new Map();
+  for (const column of columns) {
+    if (!column.relation) {
+      continue;
+    }
+    const groupKey = [
+      column.relation.name,
+      column.relation.schema ?? "",
+      column.relation.table
+    ].join(":");
+    const existingGroup = relationGroups.get(groupKey);
+    if (existingGroup) {
+      if (!existingGroup.columns.includes(column.column)) {
+        existingGroup.columns.push(column.column);
+      }
+      continue;
+    }
+    relationGroups.set(groupKey, {
+      columns: [column.column],
+      relation: column.relation
+    });
+  }
+  const relationColumns = [...relationGroups.values()].map(
+    ({ columns: relationColumns2, relation }) => {
+      const relationTarget = relation.schema ? `${relation.schema}.${relation.table}` : relation.table;
+      return `${relation.name}:${relationTarget}(${relationColumns2.join(",")})`;
+    }
+  );
+  return [...baseColumns, ...relationColumns].join(",");
+}
+function buildAthenaReadQueryFindManySelect(columns) {
+  const select = {};
+  for (const column of columns) {
+    if (!column.relation) {
+      select[column.column] = true;
+      continue;
+    }
+    const existingRelation = select[column.relation.name];
+    if (existingRelation && existingRelation !== true && isRecord3(existingRelation.select)) {
+      existingRelation.select[column.column] = true;
+      continue;
+    }
+    select[column.relation.name] = {
+      ...column.relation.schema ? { schema: column.relation.schema } : {},
+      select: {
+        [column.column]: true
+      }
+    };
+  }
+  return select;
+}
+function buildAthenaReadQueryFindManyWhere(filters) {
+  if (!filters?.length) {
+    return;
+  }
+  return filters.reduce(
+    (where, filter) => {
+      const operator = filter.operator ?? "eq";
+      where[filter.column] = operator === "eq" ? filter.value : { [operator]: filter.value };
+      return where;
+    },
+    {}
+  );
+}
+function buildAthenaReadQueryFindManyOrderBy(orderBy) {
+  const normalized = normalizeAthenaReadQueryOrderBy(orderBy);
+  if (normalized.length === 0) {
+    return;
+  }
+  if (normalized.length === 1) {
+    const primary = normalized[0];
+    if (!primary) {
+      return;
+    }
+    return {
+      ascending: primary.direction !== "desc",
+      column: primary.column
+    };
+  }
+  return Object.fromEntries(
+    normalized.map((entry) => [
+      entry.column,
+      entry.direction === "desc" ? "desc" : "asc"
+    ])
+  );
+}
+function applyAthenaReadQueryFilters(queryBuilder, filters) {
+  if (!filters?.length) {
+    return queryBuilder;
+  }
+  return filters.reduce((currentBuilder, filter) => {
+    const operator = filter.operator ?? "eq";
+    const builderMethod = currentBuilder[operator];
+    if (typeof builderMethod !== "function") {
+      return currentBuilder;
+    }
+    return builderMethod.call(currentBuilder, filter.column, filter.value);
+  }, queryBuilder);
+}
+function applyAthenaReadQuerySelectOrder(queryBuilder, orderBy) {
+  const normalized = normalizeAthenaReadQueryOrderBy(orderBy);
+  if (normalized.length === 0) {
+    return queryBuilder;
+  }
+  return normalized.reduce(
+    (builder, entry) => builder.order(entry.column, {
+      ascending: entry.direction !== "desc"
+    }),
+    queryBuilder
+  );
+}
+function clampAthenaReadQueryTotalItems(totalItems, limit) {
+  if (!limit || limit < 1) {
+    return totalItems;
+  }
+  return Math.min(totalItems, limit);
+}
+function resolveCountValue(...candidates) {
+  for (const candidate of candidates) {
+    if (typeof candidate === "number" && Number.isFinite(candidate)) {
+      return Math.max(0, Math.trunc(candidate));
+    }
+  }
+  return 0;
+}
+function resolveTotalItemsFromPage({
+  countCandidates,
+  limit,
+  page,
+  pageSize,
+  rowCount
+}) {
+  const exactCount = resolveCountValue(...countCandidates);
+  if (exactCount > 0) {
+    return clampAthenaReadQueryTotalItems(exactCount, limit);
+  }
+  if (rowCount > 0) {
+    const base = (page - 1) * pageSize + rowCount;
+    const synthetic = rowCount >= pageSize ? base + 1 : base;
+    return clampAthenaReadQueryTotalItems(synthetic, limit);
+  }
+  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,
+  pageSize,
+  query
+}) {
+  const db = client.db;
+  const baseBuilder = db.from(query.table, {
+    schema: query.schema
+  });
+  const countBuilder = applyAthenaReadQueryFilters(
+    db.from(query.table, { schema: query.schema }),
+    query.filters
+  );
+  const countResult = await countBuilder.select(query.countColumn, {
+    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 = applyAthenaReadQuerySelectOrder(
+      applyAthenaReadQueryFilters(baseBuilder, query.filters),
+      query.orderBy
+    );
+    const result2 = await selectBuilder.currentPage(pageFetch.page).pageSize(pageFetch.pageSize).select(buildAthenaReadQuerySelectString(query.columns), {
+      count: "exact"
+    });
+    const rows2 = flattenAthenaReadQueryRows(
+      Array.isArray(result2.data) ? result2.data : [],
+      query.columns,
+      query.rowKey
+    );
+    return {
+      debugAst: getAthenaDebugAst(result2) ?? void 0,
+      rows: rows2,
+      totalItems: resolveTotalItemsFromPage({
+        countCandidates: [countResult.count, result2.count],
+        limit: query.limit,
+        page: pageFetch.page,
+        pageSize,
+        rowCount: rows2.length
+      })
+    };
+  }
+  const findManyOrderBy = buildAthenaReadQueryFindManyOrderBy(query.orderBy);
+  const findManyOptions = {
+    ...findManyOrderBy ? { orderBy: findManyOrderBy } : {},
+    select: buildAthenaReadQueryFindManySelect(query.columns),
+    ...query.filters?.length ? { where: buildAthenaReadQueryFindManyWhere(query.filters) } : {}
+  };
+  const result = await baseBuilder.currentPage(pageFetch.page).pageSize(pageFetch.pageSize).findMany(findManyOptions);
+  const rows = flattenAthenaReadQueryRows(
+    Array.isArray(result.data) ? result.data : [],
+    query.columns,
+    query.rowKey
+  );
+  return {
+    debugAst: getAthenaDebugAst(result) ?? void 0,
+    rows,
+    totalItems: resolveTotalItemsFromPage({
+      countCandidates: [countResult.count, result.count],
+      limit: query.limit,
+      page: pageFetch.page,
+      pageSize,
+      rowCount: rows.length
+    })
+  };
+}
+
+// src/react/use-athena-read-query.ts
+var DEFAULT_PAGE = 1;
+var DEFAULT_PAGE_SIZE = 10;
+function isReadQueryRunnable(query) {
+  return query.table.trim().length > 0 && query.columns.length > 0 && query.countColumn.trim().length > 0;
+}
+function useAthenaReadQuery({
+  client,
+  query,
+  page = DEFAULT_PAGE,
+  pageSize = DEFAULT_PAGE_SIZE,
+  enabled = true,
+  queryKey,
+  queryKeyPrefix,
+  refetchOnMount,
+  refetchOnWindowFocus,
+  refetchOnReconnect,
+  retry
+}) {
+  const resolvedPage = page > 0 ? Math.trunc(page) : DEFAULT_PAGE;
+  const resolvedPageSize = pageSize > 0 ? Math.trunc(pageSize) : DEFAULT_PAGE_SIZE;
+  const queryEnabled = enabled && !!client && isReadQueryRunnable(query);
+  const defaultQueryKey = React.useMemo(
+    () => [
+      "athena",
+      "read-query",
+      query.mode ?? "findMany",
+      query.table,
+      query.schema,
+      query.columns,
+      query.filters,
+      query.limit,
+      query.orderBy,
+      query.rowKey,
+      query.countColumn,
+      resolvedPage,
+      resolvedPageSize
+    ],
+    [
+      query.columns,
+      query.countColumn,
+      query.filters,
+      query.limit,
+      query.mode,
+      query.orderBy,
+      query.rowKey,
+      query.schema,
+      query.table,
+      resolvedPage,
+      resolvedPageSize
+    ]
+  );
+  const resolvedQueryKey = React.useMemo(() => {
+    if (queryKey !== void 0) {
+      return queryKey;
+    }
+    if (queryKeyPrefix !== void 0) {
+      const prefix = Array.isArray(queryKeyPrefix) ? queryKeyPrefix : [queryKeyPrefix];
+      return [...prefix, ...defaultQueryKey];
+    }
+    return defaultQueryKey;
+  }, [defaultQueryKey, queryKey, queryKeyPrefix]);
+  const result = useQuery({
+    enabled: queryEnabled,
+    queryKey: resolvedQueryKey,
+    queryFn: async () => {
+      if (!client) {
+        throw new Error("Athena client is required to run the read query.");
+      }
+      return executeAthenaReadQuery({
+        client,
+        page: resolvedPage,
+        pageSize: resolvedPageSize,
+        query
+      });
+    },
+    refetchOnMount,
+    refetchOnWindowFocus,
+    refetchOnReconnect,
+    retry
+  });
+  return {
+    data: result.data,
+    rows: result.data?.rows ?? [],
+    totalItems: result.data?.totalItems ?? 0,
+    debugAst: result.data?.debugAst,
+    page: resolvedPage,
+    pageSize: resolvedPageSize,
+    error: result.error,
+    isLoading: result.isLoading,
+    isFetching: result.isFetching,
+    isSuccess: result.isSuccess,
+    isError: result.isError,
+    status: result.status,
+    refetch: result.refetch,
+    reset: result.reset
+  };
+}
 function resolveGetSession(authClient) {
   if ("getSession" in authClient && typeof authClient.getSession === "function") {
     return authClient.getSession;
@@ -2004,7 +2443,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;
@@ -2022,11 +2470,6 @@ function useSession(authClient, options = {}) {
   React.useEffect(() => {
     dataRef.current = data;
   }, [data]);
-  const toFallbackErrorDetails = (code, message, status) => ({
-    code,
-    message,
-    status
-  });
   const runFetch = React.useCallback(async () => {
     const requestId = ++requestIdRef.current;
     const hasData = dataRef.current !== null;
@@ -2089,6 +2532,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 = React.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] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const [isChecking, setIsChecking] = React.useState(enabled);
+  const requestIdRef = React.useRef(0);
+  const mountedRef = React.useRef(true);
+  const runCheck = React.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]);
+  React.useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  React.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 = React.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 = React.useMemo(
@@ -2193,7 +2841,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__namespace.useState(null);
   const [loading, setLoading] = React__namespace.useState(false);
   const [error, setError] = React__namespace.useState(null);
@@ -2291,7 +2945,7 @@ function resolveNullishValue(mode) {
   if (mode === "null") return null;
   return "";
 }
-function isRecord3(value) {
+function isRecord4(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function isNullableColumn(model, key) {
@@ -2300,7 +2954,7 @@ function isNullableColumn(model, key) {
 }
 function toModelFormDefaults(model, values, options) {
   const source = values;
-  if (!isRecord3(source)) {
+  if (!isRecord4(source)) {
     return {};
   }
   const mode = options?.nullishMode ?? "empty-string";
@@ -2355,8 +3009,10 @@ exports.createModelFormAdapter = createModelFormAdapter;
 exports.isAthenaGatewayError = isAthenaGatewayError;
 exports.toModelFormDefaults = toModelFormDefaults;
 exports.toModelPayload = toModelPayload;
+exports.useAdminPermission = useAdminPermission;
 exports.useAthenaGateway = useAthenaGateway;
 exports.useAthenaQueryClient = useAthenaQueryClient;
+exports.useAthenaReadQuery = useAthenaReadQuery;
 exports.useAthenaSessionClient = useAthenaSessionClient;
 exports.useMutation = useMutation;
 exports.useQuery = useQuery;