@xylex-group/athena 3.1.0 → 3.5.1

package/dist/react.js

@@ -392,7 +392,7 @@ function buildAthenaRequestHeaders(input) {
 
 // package.json
 var package_default = {
-  version: "3.1.0"
+  version: "3.5.1"
 };
 
 // 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