@xylex-group/athena 2.6.0 → 2.8.0

package/dist/react.cjs

@@ -1,8 +1,28 @@
 'use strict';
 
-var react = require('react');
+var React = require('react');
 var shim = require('use-sync-external-store/shim');
 
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespace(React);
+
 // src/gateway/use-athena-gateway.ts
 
 // src/gateway/errors.ts
@@ -151,16 +171,23 @@ var getSessionCookie = (request, config) => {
   const { cookieName = "session_token", cookiePrefix = "athena-auth" } = {};
   const parsedCookie = parseCookies(cookies);
   const getCookie = (name) => parsedCookie.get(name) || parsedCookie.get(`${SECURE_COOKIE_PREFIX}${name}`);
-  const sessionToken = getCookie(`${cookiePrefix}.${cookieName}`) || getCookie(`${cookiePrefix}-${cookieName}`);
-  if (sessionToken) {
-    return sessionToken;
+  const candidateCookieNames = Array.from(/* @__PURE__ */ new Set([
+    cookieName,
+    cookieName.replace(/_/g, "-"),
+    cookieName.replace(/-/g, "_")
+  ])).filter(Boolean);
+  for (const candidateName of candidateCookieNames) {
+    const sessionToken = getCookie(`${cookiePrefix}.${candidateName}`) || getCookie(`${cookiePrefix}-${candidateName}`);
+    if (sessionToken) {
+      return sessionToken;
+    }
   }
   return null;
 };
 
 // package.json
 var package_default = {
-  version: "2.6.0"
+  version: "2.8.0"
 };
 
 // src/sdk-version.ts
@@ -711,13 +738,13 @@ function createAthenaGatewayClient(config = {}) {
 
 // src/gateway/use-athena-gateway.ts
 function useAthenaGateway(config) {
-  const [isLoading, setIsLoading] = react.useState(false);
-  const [error, setError] = react.useState(null);
-  const [lastRequest, setLastRequest] = react.useState(
+  const [isLoading, setIsLoading] = React.useState(false);
+  const [error, setError] = React.useState(null);
+  const [lastRequest, setLastRequest] = React.useState(
     null
   );
-  const [lastResponse, setLastResponse] = react.useState(null);
-  const client = react.useMemo(
+  const [lastResponse, setLastResponse] = React.useState(null);
+  const client = React.useMemo(
     () => createAthenaGatewayClient({
       client: config?.client,
       baseUrl: config?.baseUrl,
@@ -739,7 +766,7 @@ function useAthenaGateway(config) {
       config?.organizationId
     ]
   );
-  const callWithLifecycle = react.useCallback(
+  const callWithLifecycle = React.useCallback(
     async (fn, metadata) => {
       const requestLog = {
         endpoint: metadata.endpoint,
@@ -791,7 +818,7 @@ function useAthenaGateway(config) {
     [client]
   );
   const defaultStripNulls = true;
-  const fetchGateway = react.useCallback(
+  const fetchGateway = React.useCallback(
     (payload, options) => {
       const normalizedPayload = {
         ...payload,
@@ -810,7 +837,7 @@ function useAthenaGateway(config) {
     },
     [callWithLifecycle, client]
   );
-  const insertGateway = react.useCallback(
+  const insertGateway = React.useCallback(
     (payload, options) => callWithLifecycle(() => client.insertGateway(payload, options), {
       endpoint: "/gateway/insert",
       method: "PUT",
@@ -819,7 +846,7 @@ function useAthenaGateway(config) {
     }),
     [callWithLifecycle, client]
   );
-  const updateGateway = react.useCallback(
+  const updateGateway = React.useCallback(
     (payload, options) => {
       const normalizedPayload = {
         ...payload,
@@ -838,7 +865,7 @@ function useAthenaGateway(config) {
     },
     [callWithLifecycle, client]
   );
-  const deleteGateway = react.useCallback(
+  const deleteGateway = React.useCallback(
     (payload, options) => {
       if (!payload.resource_id) {
         throw new Error(
@@ -852,7 +879,7 @@ function useAthenaGateway(config) {
     },
     [callWithLifecycle, client]
   );
-  const rpcGateway = react.useCallback(
+  const rpcGateway = React.useCallback(
     (payload, options) => callWithLifecycle(() => client.rpcGateway(payload, options), {
       endpoint: options?.get ? `/rpc/${payload.function}` : "/gateway/rpc",
       method: options?.get ? "GET" : "POST",
@@ -1566,22 +1593,22 @@ function createAthenaQueryClient(config) {
 function attachStateAdapter(client, adapter) {
   return client.attachAdapter(adapter);
 }
-var AthenaQueryClientContext = react.createContext(null);
+var AthenaQueryClientContext = React.createContext(null);
 function AthenaQueryClientProvider(props) {
-  const memoizedClient = react.useMemo(() => {
+  const memoizedClient = React.useMemo(() => {
     if (props.client) {
       return props.client;
     }
     return createAthenaQueryClient(props.config);
   }, [props.client, props.config]);
-  return react.createElement(
+  return React.createElement(
     AthenaQueryClientContext.Provider,
     { value: memoizedClient },
     props.children
   );
 }
 function useAthenaQueryClient() {
-  const client = react.useContext(AthenaQueryClientContext);
+  const client = React.useContext(AthenaQueryClientContext);
   if (!client) {
     throw new Error(
       "No AthenaQueryClient found. Wrap your component tree with AthenaQueryClientProvider."
@@ -1602,48 +1629,48 @@ function getBrowserTarget() {
 }
 function useQuery(options) {
   const client = useAthenaQueryClient();
-  const queryKeyRef = react.useRef(options.queryKey);
+  const queryKeyRef = React.useRef(options.queryKey);
   queryKeyRef.current = options.queryKey;
-  const queryFnRef = react.useRef(options.queryFn);
+  const queryFnRef = React.useRef(options.queryFn);
   queryFnRef.current = options.queryFn;
-  const selectRef = react.useRef(options.select);
+  const selectRef = React.useRef(options.select);
   selectRef.current = options.select;
-  const onSuccessRef = react.useRef(options.onSuccess);
+  const onSuccessRef = React.useRef(options.onSuccess);
   onSuccessRef.current = options.onSuccess;
-  const onErrorRef = react.useRef(options.onError);
+  const onErrorRef = React.useRef(options.onError);
   onErrorRef.current = options.onError;
-  const onSettledRef = react.useRef(options.onSettled);
+  const onSettledRef = React.useRef(options.onSettled);
   onSettledRef.current = options.onSettled;
-  const enabledRef = react.useRef(options.enabled ?? true);
+  const enabledRef = React.useRef(options.enabled ?? true);
   enabledRef.current = options.enabled ?? true;
-  const retryRef = react.useRef(options.retry);
+  const retryRef = React.useRef(options.retry);
   retryRef.current = options.retry;
-  const retryDelayRef = react.useRef(options.retryDelay);
+  const retryDelayRef = React.useRef(options.retryDelay);
   retryDelayRef.current = options.retryDelay;
-  const initialDataRef = react.useRef(options.initialData);
+  const initialDataRef = React.useRef(options.initialData);
   initialDataRef.current = options.initialData;
-  const refetchOnMountRef = react.useRef(options.refetchOnMount);
+  const refetchOnMountRef = React.useRef(options.refetchOnMount);
   refetchOnMountRef.current = options.refetchOnMount;
-  const refetchOnWindowFocusRef = react.useRef(options.refetchOnWindowFocus);
+  const refetchOnWindowFocusRef = React.useRef(options.refetchOnWindowFocus);
   refetchOnWindowFocusRef.current = options.refetchOnWindowFocus;
-  const refetchOnReconnectRef = react.useRef(options.refetchOnReconnect);
+  const refetchOnReconnectRef = React.useRef(options.refetchOnReconnect);
   refetchOnReconnectRef.current = options.refetchOnReconnect;
-  const queryKeyToken = react.useMemo(
+  const queryKeyToken = React.useMemo(
     () => client.getQueryKeyToken(options.queryKey),
     [client, options.queryKey]
   );
-  const activeQueryKeyTokenRef = react.useRef(queryKeyToken);
+  const activeQueryKeyTokenRef = React.useRef(queryKeyToken);
   activeQueryKeyTokenRef.current = queryKeyToken;
-  const subscribe = react.useCallback(
+  const subscribe = React.useCallback(
     (listener) => client.subscribeQuery(queryKeyToken, listener),
     [client, queryKeyToken]
   );
-  const getSnapshot = react.useCallback(
+  const getSnapshot = React.useCallback(
     () => client.getQueryState(queryKeyToken),
     [client, queryKeyToken]
   );
   const snapshot = shim.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  const effectiveSnapshot = react.useMemo(() => {
+  const effectiveSnapshot = React.useMemo(() => {
     if (snapshot.status === "idle" && snapshot.data === void 0 && initialDataRef.current !== void 0) {
       return {
         ...snapshot,
@@ -1654,7 +1681,7 @@ function useQuery(options) {
     }
     return snapshot;
   }, [snapshot]);
-  const runQuery = react.useCallback(
+  const runQuery = React.useCallback(
     async (force = false) => {
       const result = await client.executeQuery({
         queryKey: queryKeyRef.current,
@@ -1681,8 +1708,8 @@ function useQuery(options) {
     },
     [client, queryKeyToken]
   );
-  const lastAutoKeyRef = react.useRef(null);
-  react.useEffect(() => {
+  const lastAutoKeyRef = React.useRef(null);
+  React.useEffect(() => {
     const refetchOnMount = refetchOnMountRef.current ?? client.defaultQueryOptions.refetchOnMount ?? true;
     const isFirstRenderForKey = lastAutoKeyRef.current !== queryKeyToken;
     lastAutoKeyRef.current = queryKeyToken;
@@ -1695,7 +1722,7 @@ function useQuery(options) {
       void runQuery(false);
     }
   }, [client, queryKeyToken, runQuery]);
-  react.useEffect(() => {
+  React.useEffect(() => {
     const browser = getBrowserTarget();
     if (!browser || !enabledRef.current) {
       return void 0;
@@ -1713,7 +1740,7 @@ function useQuery(options) {
       browser.removeEventListener("focus", onFocus);
     };
   }, [client, runQuery]);
-  react.useEffect(() => {
+  React.useEffect(() => {
     const browser = getBrowserTarget();
     if (!browser || !enabledRef.current) {
       return void 0;
@@ -1731,8 +1758,8 @@ function useQuery(options) {
       browser.removeEventListener("online", onReconnect);
     };
   }, [client, runQuery]);
-  const refetch = react.useCallback(() => runQuery(true), [runQuery]);
-  const reset = react.useCallback(() => {
+  const refetch = React.useCallback(() => runQuery(true), [runQuery]);
+  const reset = React.useCallback(() => {
     client.resetQuery(queryKeyRef.current);
   }, [client]);
   return {
@@ -1751,38 +1778,38 @@ function useQuery(options) {
 }
 function useMutation(options) {
   const client = useAthenaQueryClient();
-  const mutationKeyRef = react.useRef(options.mutationKey);
+  const mutationKeyRef = React.useRef(options.mutationKey);
   mutationKeyRef.current = options.mutationKey;
-  const mutationFnRef = react.useRef(options.mutationFn);
+  const mutationFnRef = React.useRef(options.mutationFn);
   mutationFnRef.current = options.mutationFn;
-  const selectRef = react.useRef(options.select);
+  const selectRef = React.useRef(options.select);
   selectRef.current = options.select;
-  const retryRef = react.useRef(options.retry);
+  const retryRef = React.useRef(options.retry);
   retryRef.current = options.retry;
-  const retryDelayRef = react.useRef(options.retryDelay);
+  const retryDelayRef = React.useRef(options.retryDelay);
   retryDelayRef.current = options.retryDelay;
-  const onMutateRef = react.useRef(options.onMutate);
+  const onMutateRef = React.useRef(options.onMutate);
   onMutateRef.current = options.onMutate;
-  const onSuccessRef = react.useRef(options.onSuccess);
+  const onSuccessRef = React.useRef(options.onSuccess);
   onSuccessRef.current = options.onSuccess;
-  const onErrorRef = react.useRef(options.onError);
+  const onErrorRef = React.useRef(options.onError);
   onErrorRef.current = options.onError;
-  const onSettledRef = react.useRef(options.onSettled);
+  const onSettledRef = React.useRef(options.onSettled);
   onSettledRef.current = options.onSettled;
-  const mutationKeyToken = react.useMemo(
+  const mutationKeyToken = React.useMemo(
     () => client.getMutationKeyToken(options.mutationKey),
     [client, options.mutationKey]
   );
-  const subscribe = react.useCallback(
+  const subscribe = React.useCallback(
     (listener) => client.subscribeMutation(mutationKeyToken, listener),
     [client, mutationKeyToken]
   );
-  const getSnapshot = react.useCallback(
+  const getSnapshot = React.useCallback(
     () => client.getMutationState(mutationKeyToken),
     [client, mutationKeyToken]
   );
   const snapshot = shim.useSyncExternalStore(subscribe, getSnapshot, getSnapshot);
-  const mutateAsync = react.useCallback(
+  const mutateAsync = React.useCallback(
     async (variables) => {
       await onMutateRef.current?.(variables);
       const result = await client.executeMutation({
@@ -1806,13 +1833,13 @@ function useMutation(options) {
     },
     [client, mutationKeyToken]
   );
-  const mutate = react.useCallback(
+  const mutate = React.useCallback(
     (variables) => {
       void mutateAsync(variables).catch(() => void 0);
     },
     [mutateAsync]
   );
-  const reset = react.useCallback(() => {
+  const reset = React.useCallback(() => {
     client.resetMutation(mutationKeyRef.current);
   }, [client]);
   return {
@@ -1843,17 +1870,17 @@ function resolveGetSession(authClient) {
 function useSession(authClient, options = {}) {
   const enabled = options.enabled ?? true;
   const refetchOnMount = options.refetchOnMount ?? true;
-  const [data, setData] = react.useState(null);
-  const [error, setError] = react.useState(null);
-  const [isPending, setIsPending] = react.useState(enabled);
-  const [isRefetching, setIsRefetching] = react.useState(false);
-  const requestIdRef = react.useRef(0);
-  const mountedRef = react.useRef(true);
-  const dataRef = react.useRef(null);
+  const [data, setData] = React.useState(null);
+  const [error, setError] = React.useState(null);
+  const [isPending, setIsPending] = React.useState(enabled);
+  const [isRefetching, setIsRefetching] = React.useState(false);
+  const requestIdRef = React.useRef(0);
+  const mountedRef = React.useRef(true);
+  const dataRef = React.useRef(null);
   const getSession = resolveGetSession(
     authClient
   );
-  react.useEffect(() => {
+  React.useEffect(() => {
     dataRef.current = data;
   }, [data]);
   const toFallbackErrorDetails = (code, message, status) => ({
@@ -1861,7 +1888,7 @@ function useSession(authClient, options = {}) {
     message,
     status
   });
-  const runFetch = react.useCallback(async () => {
+  const runFetch = React.useCallback(async () => {
     const requestId = ++requestIdRef.current;
     const hasData = dataRef.current !== null;
     if (hasData) {
@@ -1901,7 +1928,7 @@ function useSession(authClient, options = {}) {
       }
     }
   }, [getSession, options.callOptions, options.fetchInput]);
-  react.useEffect(() => {
+  React.useEffect(() => {
     mountedRef.current = true;
     if (enabled && refetchOnMount) {
       void runFetch();
@@ -1912,7 +1939,7 @@ function useSession(authClient, options = {}) {
       mountedRef.current = false;
     };
   }, [enabled, refetchOnMount, runFetch]);
-  const refetch = react.useCallback(async () => {
+  const refetch = React.useCallback(async () => {
     return await runFetch();
   }, [runFetch]);
   return {
@@ -1923,6 +1950,85 @@ function useSession(authClient, options = {}) {
     refetch
   };
 }
+function useStorageUpload(options) {
+  const {
+    storage,
+    onProgress,
+    ...defaults
+  } = options;
+  const [uploading, setUploading] = React__namespace.useState(false);
+  const [progress, setProgress] = React__namespace.useState(null);
+  const [error, setError] = React__namespace.useState(null);
+  const [result, setResult] = React__namespace.useState(null);
+  const controllerRef = React__namespace.useRef(null);
+  const reset = React__namespace.useCallback(() => {
+    setUploading(false);
+    setProgress(null);
+    setError(null);
+    setResult(null);
+  }, []);
+  const abort = React__namespace.useCallback(() => {
+    controllerRef.current?.abort();
+    controllerRef.current = null;
+  }, []);
+  const upload = React__namespace.useCallback(async (input, callOptions) => {
+    const controller = callOptions?.signal ? null : new AbortController();
+    controllerRef.current = controller;
+    setUploading(true);
+    setError(null);
+    setResult(null);
+    const request = normalizeHookUploadInput(defaults, input, (progressEvent) => {
+      setProgress(progressEvent);
+      onProgress?.(progressEvent);
+      if (isStorageUploadInput(input)) {
+        input.onProgress?.(progressEvent);
+      }
+    });
+    try {
+      const uploaded = await storage.file.upload(request, {
+        ...callOptions,
+        signal: callOptions?.signal ?? controller?.signal
+      });
+      setResult(uploaded);
+      return uploaded;
+    } catch (uploadError) {
+      setError(uploadError);
+      throw uploadError;
+    } finally {
+      setUploading(false);
+      if (controllerRef.current === controller) {
+        controllerRef.current = null;
+      }
+    }
+  }, [defaults, onProgress, storage]);
+  return {
+    uploading,
+    progress,
+    percent: progress?.aggregatePercent ?? 0,
+    error,
+    result,
+    upload,
+    abort,
+    reset
+  };
+}
+function normalizeHookUploadInput(defaults, input, onProgress) {
+  if (isStorageUploadInput(input)) {
+    return {
+      ...defaults,
+      ...input,
+      onProgress
+    };
+  }
+  return {
+    ...defaults,
+    files: input,
+    onProgress
+  };
+}
+function isStorageUploadInput(input) {
+  return Boolean(input) && typeof input === "object" && "files" in input && "s3_id" in input;
+}
 
 // src/schema/model-form.ts
 function resolveNullishValue(mode) {
@@ -1999,5 +2105,6 @@ exports.useAthenaQueryClient = useAthenaQueryClient;
 exports.useMutation = useMutation;
 exports.useQuery = useQuery;
 exports.useSession = useSession;
+exports.useStorageUpload = useStorageUpload;
 //# sourceMappingURL=react.cjs.map
 //# sourceMappingURL=react.cjs.map