@fluxbase/sdk-react 0.1.0-rc.1 → 2026.1.1-rc.10

package/dist/index.mjs

@@ -20,12 +20,13 @@ function useUser() {
   return useQuery({
     queryKey: ["fluxbase", "auth", "user"],
     queryFn: async () => {
-      const session = client.auth.getSession();
-      if (!session) {
+      const { data } = await client.auth.getSession();
+      if (!data?.session) {
         return null;
       }
       try {
-        return await client.auth.getCurrentUser();
+        const result = await client.auth.getCurrentUser();
+        return result.data?.user ?? null;
       } catch {
         return null;
       }
@@ -38,7 +39,10 @@ function useSession() {
   const client = useFluxbaseClient();
   return useQuery({
     queryKey: ["fluxbase", "auth", "session"],
-    queryFn: () => client.auth.getSession(),
+    queryFn: async () => {
+      const { data } = await client.auth.getSession();
+      return data?.session ?? null;
+    },
     staleTime: 1e3 * 60 * 5
     // 5 minutes
   });
@@ -65,9 +69,17 @@ function useSignUp() {
     mutationFn: async (credentials) => {
       return await client.auth.signUp(credentials);
     },
-    onSuccess: (session) => {
-      queryClient.setQueryData(["fluxbase", "auth", "session"], session);
-      queryClient.setQueryData(["fluxbase", "auth", "user"], session.user);
+    onSuccess: (response) => {
+      if (response.data) {
+        queryClient.setQueryData(
+          ["fluxbase", "auth", "session"],
+          response.data.session
+        );
+        queryClient.setQueryData(
+          ["fluxbase", "auth", "user"],
+          response.data.user
+        );
+      }
     }
   });
 }
@@ -120,12 +132,303 @@ function useAuth() {
   };
 }
 
+// src/use-captcha.ts
+import { useQuery as useQuery2 } from "@tanstack/react-query";
+import { useCallback, useEffect, useRef, useState } from "react";
+function useCaptchaConfig() {
+  const client = useFluxbaseClient();
+  return useQuery2({
+    queryKey: ["fluxbase", "auth", "captcha", "config"],
+    queryFn: async () => {
+      const { data, error } = await client.auth.getCaptchaConfig();
+      if (error) {
+        throw error;
+      }
+      return data;
+    },
+    staleTime: 1e3 * 60 * 60,
+    // Cache for 1 hour (config rarely changes)
+    gcTime: 1e3 * 60 * 60 * 24
+    // Keep in cache for 24 hours
+  });
+}
+function useCaptcha(provider) {
+  const [token, setToken] = useState(null);
+  const [isReady, setIsReady] = useState(false);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const executeResolverRef = useRef(null);
+  const executeRejecterRef = useRef(null);
+  const onVerify = useCallback((newToken) => {
+    setToken(newToken);
+    setIsLoading(false);
+    setError(null);
+    setIsReady(true);
+    if (executeResolverRef.current) {
+      executeResolverRef.current(newToken);
+      executeResolverRef.current = null;
+      executeRejecterRef.current = null;
+    }
+  }, []);
+  const onExpire = useCallback(() => {
+    setToken(null);
+    setIsReady(true);
+  }, []);
+  const onError = useCallback((err) => {
+    setError(err);
+    setIsLoading(false);
+    setToken(null);
+    if (executeRejecterRef.current) {
+      executeRejecterRef.current(err);
+      executeResolverRef.current = null;
+      executeRejecterRef.current = null;
+    }
+  }, []);
+  const reset = useCallback(() => {
+    setToken(null);
+    setError(null);
+    setIsLoading(false);
+  }, []);
+  const execute = useCallback(async () => {
+    if (token) {
+      return token;
+    }
+    if (!provider) {
+      return "";
+    }
+    setIsLoading(true);
+    setError(null);
+    return new Promise((resolve, reject) => {
+      executeResolverRef.current = resolve;
+      executeRejecterRef.current = reject;
+    });
+  }, [token, provider]);
+  useEffect(() => {
+    if (provider) {
+      setIsReady(true);
+    }
+  }, [provider]);
+  return {
+    token,
+    isReady,
+    isLoading,
+    error,
+    reset,
+    execute,
+    onVerify,
+    onExpire,
+    onError
+  };
+}
+function isCaptchaRequiredForEndpoint(config, endpoint) {
+  if (!config?.enabled) {
+    return false;
+  }
+  return config.endpoints?.includes(endpoint) ?? false;
+}
+
+// src/use-auth-config.ts
+import { useQuery as useQuery3 } from "@tanstack/react-query";
+function useAuthConfig() {
+  const client = useFluxbaseClient();
+  return useQuery3({
+    queryKey: ["fluxbase", "auth", "config"],
+    queryFn: async () => {
+      const { data, error } = await client.auth.getAuthConfig();
+      if (error) {
+        throw error;
+      }
+      return data;
+    },
+    staleTime: 1e3 * 60 * 5,
+    // Cache for 5 minutes (config changes infrequently)
+    gcTime: 1e3 * 60 * 60
+    // Keep in cache for 1 hour
+  });
+}
+
+// src/use-saml.ts
+import { useMutation as useMutation2, useQuery as useQuery4, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+function useSAMLProviders() {
+  const client = useFluxbaseClient();
+  return useQuery4({
+    queryKey: ["fluxbase", "auth", "saml", "providers"],
+    queryFn: async () => {
+      const { data, error } = await client.auth.getSAMLProviders();
+      if (error) throw error;
+      return data.providers;
+    },
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes - providers don't change often
+  });
+}
+function useGetSAMLLoginUrl() {
+  const client = useFluxbaseClient();
+  return useMutation2({
+    mutationFn: async ({
+      provider,
+      options
+    }) => {
+      return await client.auth.getSAMLLoginUrl(provider, options);
+    }
+  });
+}
+function useSignInWithSAML() {
+  const client = useFluxbaseClient();
+  return useMutation2({
+    mutationFn: async ({
+      provider,
+      options
+    }) => {
+      return await client.auth.signInWithSAML(provider, options);
+    }
+  });
+}
+function useHandleSAMLCallback() {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient2();
+  return useMutation2({
+    mutationFn: async ({
+      samlResponse,
+      provider
+    }) => {
+      return await client.auth.handleSAMLCallback(samlResponse, provider);
+    },
+    onSuccess: (result) => {
+      if (result.data) {
+        queryClient.setQueryData(
+          ["fluxbase", "auth", "session"],
+          result.data.session
+        );
+        queryClient.setQueryData(
+          ["fluxbase", "auth", "user"],
+          result.data.user
+        );
+        queryClient.invalidateQueries({ queryKey: ["fluxbase"] });
+      }
+    }
+  });
+}
+function useSAMLMetadataUrl() {
+  const client = useFluxbaseClient();
+  return (provider) => {
+    return client.auth.getSAMLMetadataUrl(provider);
+  };
+}
+
+// src/use-graphql.ts
+import { useMutation as useMutation3, useQuery as useQuery5, useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+function useGraphQLQuery(queryKey, query, options) {
+  const client = useFluxbaseClient();
+  const normalizedKey = Array.isArray(queryKey) ? ["fluxbase", "graphql", ...queryKey] : ["fluxbase", "graphql", queryKey];
+  return useQuery5({
+    queryKey: normalizedKey,
+    queryFn: async () => {
+      const response = await client.graphql.execute(
+        query,
+        options?.variables,
+        options?.operationName,
+        options?.requestOptions
+      );
+      if (response.errors && response.errors.length > 0) {
+        throw response.errors[0];
+      }
+      return response.data;
+    },
+    enabled: options?.enabled ?? true,
+    staleTime: options?.staleTime ?? 0,
+    gcTime: options?.gcTime,
+    refetchOnWindowFocus: options?.refetchOnWindowFocus ?? true,
+    select: options?.select
+  });
+}
+function useGraphQLMutation(mutation, options) {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient3();
+  return useMutation3({
+    mutationFn: async (variables) => {
+      const response = await client.graphql.execute(
+        mutation,
+        variables,
+        options?.operationName,
+        options?.requestOptions
+      );
+      if (response.errors && response.errors.length > 0) {
+        throw response.errors[0];
+      }
+      return response.data;
+    },
+    onSuccess: (data, variables) => {
+      if (options?.invalidateQueries) {
+        for (const key of options.invalidateQueries) {
+          queryClient.invalidateQueries({
+            queryKey: ["fluxbase", "graphql", key]
+          });
+        }
+      }
+      if (options?.onSuccess && data !== void 0) {
+        options.onSuccess(data, variables);
+      }
+    },
+    onError: (error, variables) => {
+      if (options?.onError) {
+        options.onError(error, variables);
+      }
+    }
+  });
+}
+function useGraphQLIntrospection(options) {
+  const client = useFluxbaseClient();
+  return useQuery5({
+    queryKey: ["fluxbase", "graphql", "__introspection"],
+    queryFn: async () => {
+      const response = await client.graphql.introspect(options?.requestOptions);
+      if (response.errors && response.errors.length > 0) {
+        throw response.errors[0];
+      }
+      return response.data;
+    },
+    enabled: options?.enabled ?? true,
+    staleTime: options?.staleTime ?? 1e3 * 60 * 5
+    // 5 minutes - schema doesn't change often
+  });
+}
+function useGraphQL() {
+  const client = useFluxbaseClient();
+  return {
+    /**
+     * Execute a GraphQL query
+     */
+    executeQuery: (query, variables, options) => {
+      return client.graphql.query(query, variables, options);
+    },
+    /**
+     * Execute a GraphQL mutation
+     */
+    executeMutation: (mutation, variables, options) => {
+      return client.graphql.mutation(mutation, variables, options);
+    },
+    /**
+     * Execute a GraphQL operation with an explicit operation name
+     */
+    execute: (document, variables, operationName, options) => {
+      return client.graphql.execute(document, variables, operationName, options);
+    },
+    /**
+     * Fetch the GraphQL schema via introspection
+     */
+    introspect: (options) => {
+      return client.graphql.introspect(options);
+    }
+  };
+}
+
 // src/use-query.ts
-import { useQuery as useQuery2, useMutation as useMutation2, useQueryClient as useQueryClient2 } from "@tanstack/react-query";
+import { useQuery as useQuery6, useMutation as useMutation4, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
 function useFluxbaseQuery(buildQuery, options) {
   const client = useFluxbaseClient();
   const queryKey = options?.queryKey || ["fluxbase", "query", buildQuery.toString()];
-  return useQuery2({
+  return useQuery6({
     queryKey,
     queryFn: async () => {
       const query = buildQuery(client);
@@ -153,8 +456,8 @@ function useTable(table, buildQuery, options) {
 }
 function useInsert(table) {
   const client = useFluxbaseClient();
-  const queryClient = useQueryClient2();
-  return useMutation2({
+  const queryClient = useQueryClient4();
+  return useMutation4({
     mutationFn: async (data) => {
       const query = client.from(table);
       const { data: result, error } = await query.insert(data);
@@ -170,8 +473,8 @@ function useInsert(table) {
 }
 function useUpdate(table) {
   const client = useFluxbaseClient();
-  const queryClient = useQueryClient2();
-  return useMutation2({
+  const queryClient = useQueryClient4();
+  return useMutation4({
     mutationFn: async (params) => {
       const query = client.from(table);
       const builtQuery = params.buildQuery(query);
@@ -188,8 +491,8 @@ function useUpdate(table) {
 }
 function useUpsert(table) {
   const client = useFluxbaseClient();
-  const queryClient = useQueryClient2();
-  return useMutation2({
+  const queryClient = useQueryClient4();
+  return useMutation4({
     mutationFn: async (data) => {
       const query = client.from(table);
       const { data: result, error } = await query.upsert(data);
@@ -205,8 +508,8 @@ function useUpsert(table) {
 }
 function useDelete(table) {
   const client = useFluxbaseClient();
-  const queryClient = useQueryClient2();
-  return useMutation2({
+  const queryClient = useQueryClient4();
+  return useMutation4({
     mutationFn: async (buildQuery) => {
       const query = client.from(table);
       const builtQuery = buildQuery(query);
@@ -222,12 +525,14 @@ function useDelete(table) {
 }
 
 // src/use-realtime.ts
-import { useEffect, useRef } from "react";
-import { useQueryClient as useQueryClient3 } from "@tanstack/react-query";
+import { useEffect as useEffect2, useRef as useRef2 } from "react";
+import { useQueryClient as useQueryClient5 } from "@tanstack/react-query";
 function useRealtime(options) {
   const client = useFluxbaseClient();
-  const queryClient = useQueryClient3();
-  const channelRef = useRef(null);
+  const queryClient = useQueryClient5();
+  const channelRef = useRef2(
+    null
+  );
   const {
     channel: channelName,
     event = "*",
@@ -236,7 +541,7 @@ function useRealtime(options) {
     invalidateKey,
     enabled = true
   } = options;
-  useEffect(() => {
+  useEffect2(() => {
     if (!enabled) {
       return;
     }
@@ -257,7 +562,16 @@ function useRealtime(options) {
       channel.unsubscribe();
       channelRef.current = null;
     };
-  }, [client, channelName, event, callback, autoInvalidate, invalidateKey, queryClient, enabled]);
+  }, [
+    client,
+    channelName,
+    event,
+    callback,
+    autoInvalidate,
+    invalidateKey,
+    queryClient,
+    enabled
+  ]);
   return {
     channel: channelRef.current
   };
@@ -294,12 +608,23 @@ function useTableDeletes(table, callback, options) {
 }
 
 // src/use-storage.ts
-import { useMutation as useMutation3, useQuery as useQuery3, useQueryClient as useQueryClient4 } from "@tanstack/react-query";
+import { useState as useState2 } from "react";
+import {
+  useMutation as useMutation5,
+  useQuery as useQuery7,
+  useQueryClient as useQueryClient6
+} from "@tanstack/react-query";
 function useStorageList(bucket, options) {
   const client = useFluxbaseClient();
   const { prefix, limit, offset, ...queryOptions } = options || {};
-  return useQuery3({
-    queryKey: ["fluxbase", "storage", bucket, "list", { prefix, limit, offset }],
+  return useQuery7({
+    queryKey: [
+      "fluxbase",
+      "storage",
+      bucket,
+      "list",
+      { prefix, limit, offset }
+    ],
     queryFn: async () => {
       const { data, error } = await client.storage.from(bucket).list({ prefix, limit, offset });
       if (error) {
@@ -312,8 +637,8 @@ function useStorageList(bucket, options) {
 }
 function useStorageUpload(bucket) {
   const client = useFluxbaseClient();
-  const queryClient = useQueryClient4();
-  return useMutation3({
+  const queryClient = useQueryClient6();
+  return useMutation5({
     mutationFn: async (params) => {
       const { path, file, options } = params;
       const { data, error } = await client.storage.from(bucket).upload(path, file, options);
@@ -323,13 +648,49 @@ function useStorageUpload(bucket) {
       return data;
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", bucket, "list"] });
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "storage", bucket, "list"]
+      });
     }
   });
 }
+function useStorageUploadWithProgress(bucket) {
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient6();
+  const [progress, setProgress] = useState2(null);
+  const mutation = useMutation5({
+    mutationFn: async (params) => {
+      const { path, file, options } = params;
+      setProgress({ loaded: 0, total: 0, percentage: 0 });
+      const { data, error } = await client.storage.from(bucket).upload(path, file, {
+        ...options,
+        onUploadProgress: (p) => {
+          setProgress(p);
+        }
+      });
+      if (error) {
+        throw error;
+      }
+      return data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "storage", bucket, "list"]
+      });
+    },
+    onError: () => {
+      setProgress(null);
+    }
+  });
+  return {
+    upload: mutation,
+    progress,
+    reset: () => setProgress(null)
+  };
+}
 function useStorageDownload(bucket, path, enabled = true) {
   const client = useFluxbaseClient();
-  return useQuery3({
+  return useQuery7({
     queryKey: ["fluxbase", "storage", bucket, "download", path],
     queryFn: async () => {
       if (!path) {
@@ -346,8 +707,8 @@ function useStorageDownload(bucket, path, enabled = true) {
 }
 function useStorageDelete(bucket) {
   const client = useFluxbaseClient();
-  const queryClient = useQueryClient4();
-  return useMutation3({
+  const queryClient = useQueryClient6();
+  return useMutation5({
     mutationFn: async (paths) => {
       const { error } = await client.storage.from(bucket).remove(paths);
       if (error) {
@@ -355,7 +716,9 @@ function useStorageDelete(bucket) {
       }
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", bucket, "list"] });
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "storage", bucket, "list"]
+      });
     }
   });
 }
@@ -367,9 +730,16 @@ function useStoragePublicUrl(bucket, path) {
   const { data } = client.storage.from(bucket).getPublicUrl(path);
   return data.publicUrl;
 }
+function useStorageTransformUrl(bucket, path, transform) {
+  const client = useFluxbaseClient();
+  if (!path) {
+    return null;
+  }
+  return client.storage.from(bucket).getTransformUrl(path, transform);
+}
 function useStorageSignedUrl(bucket, path, expiresIn) {
   const client = useFluxbaseClient();
-  return useQuery3({
+  return useQuery7({
     queryKey: ["fluxbase", "storage", bucket, "signed-url", path, expiresIn],
     queryFn: async () => {
       if (!path) {
@@ -386,10 +756,39 @@ function useStorageSignedUrl(bucket, path, expiresIn) {
     // Refresh 1 minute before expiry
   });
 }
+function useStorageSignedUrlWithOptions(bucket, path, options) {
+  const client = useFluxbaseClient();
+  const expiresIn = options?.expiresIn;
+  const transformKey = options?.transform ? JSON.stringify(options.transform) : null;
+  return useQuery7({
+    queryKey: [
+      "fluxbase",
+      "storage",
+      bucket,
+      "signed-url",
+      path,
+      expiresIn,
+      transformKey
+    ],
+    queryFn: async () => {
+      if (!path) {
+        return null;
+      }
+      const { data, error } = await client.storage.from(bucket).createSignedUrl(path, options);
+      if (error) {
+        throw error;
+      }
+      return data?.signedUrl || null;
+    },
+    enabled: !!path,
+    staleTime: expiresIn ? expiresIn * 1e3 - 6e4 : 1e3 * 60 * 50
+    // Refresh 1 minute before expiry
+  });
+}
 function useStorageMove(bucket) {
   const client = useFluxbaseClient();
-  const queryClient = useQueryClient4();
-  return useMutation3({
+  const queryClient = useQueryClient6();
+  return useMutation5({
     mutationFn: async (params) => {
       const { fromPath, toPath } = params;
       const { data, error } = await client.storage.from(bucket).move(fromPath, toPath);
@@ -399,14 +798,16 @@ function useStorageMove(bucket) {
       return data;
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", bucket, "list"] });
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "storage", bucket, "list"]
+      });
     }
   });
 }
 function useStorageCopy(bucket) {
   const client = useFluxbaseClient();
-  const queryClient = useQueryClient4();
-  return useMutation3({
+  const queryClient = useQueryClient6();
+  return useMutation5({
     mutationFn: async (params) => {
       const { fromPath, toPath } = params;
       const { data, error } = await client.storage.from(bucket).copy(fromPath, toPath);
@@ -416,13 +817,15 @@ function useStorageCopy(bucket) {
       return data;
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", bucket, "list"] });
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "storage", bucket, "list"]
+      });
     }
   });
 }
 function useStorageBuckets() {
   const client = useFluxbaseClient();
-  return useQuery3({
+  return useQuery7({
     queryKey: ["fluxbase", "storage", "buckets"],
     queryFn: async () => {
       const { data, error } = await client.storage.listBuckets();
@@ -435,8 +838,8 @@ function useStorageBuckets() {
 }
 function useCreateBucket() {
   const client = useFluxbaseClient();
-  const queryClient = useQueryClient4();
-  return useMutation3({
+  const queryClient = useQueryClient6();
+  return useMutation5({
     mutationFn: async (bucketName) => {
       const { error } = await client.storage.createBucket(bucketName);
       if (error) {
@@ -444,14 +847,16 @@ function useCreateBucket() {
       }
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", "buckets"] });
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "storage", "buckets"]
+      });
     }
   });
 }
 function useDeleteBucket() {
   const client = useFluxbaseClient();
-  const queryClient = useQueryClient4();
-  return useMutation3({
+  const queryClient = useQueryClient6();
+  return useMutation5({
     mutationFn: async (bucketName) => {
       const { error } = await client.storage.deleteBucket(bucketName);
       if (error) {
@@ -459,74 +864,30 @@ function useDeleteBucket() {
       }
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", "buckets"] });
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "storage", "buckets"]
+      });
     }
   });
 }
 
-// src/use-rpc.ts
-import { useQuery as useQuery4, useMutation as useMutation4 } from "@tanstack/react-query";
-function useRPC(functionName, params, options) {
-  const client = useFluxbaseClient();
-  return useQuery4({
-    queryKey: ["rpc", functionName, params],
-    queryFn: async () => {
-      const { data, error } = await client.rpc(functionName, params);
-      if (error) {
-        throw new Error(error.message);
-      }
-      return data;
-    },
-    ...options
-  });
-}
-function useRPCMutation(functionName, options) {
-  const client = useFluxbaseClient();
-  return useMutation4({
-    mutationFn: async (params) => {
-      const { data, error } = await client.rpc(functionName, params);
-      if (error) {
-        throw new Error(error.message);
-      }
-      return data;
-    },
-    ...options
-  });
-}
-function useRPCBatch(calls, options) {
-  const client = useFluxbaseClient();
-  return useQuery4({
-    queryKey: ["rpc-batch", calls],
-    queryFn: async () => {
-      const results = await Promise.all(
-        calls.map(async ({ name, params }) => {
-          const { data, error } = await client.rpc(name, params);
-          if (error) {
-            throw new Error(`${name}: ${error.message}`);
-          }
-          return data;
-        })
-      );
-      return results;
-    },
-    ...options
-  });
-}
-
 // src/use-admin-auth.ts
-import { useState, useEffect as useEffect2, useCallback } from "react";
+import { useState as useState3, useEffect as useEffect3, useCallback as useCallback2 } from "react";
 function useAdminAuth(options = {}) {
   const { autoCheck = true } = options;
   const client = useFluxbaseClient();
-  const [user, setUser] = useState(null);
-  const [isLoading, setIsLoading] = useState(autoCheck);
-  const [error, setError] = useState(null);
-  const checkAuth = useCallback(async () => {
+  const [user, setUser] = useState3(null);
+  const [isLoading, setIsLoading] = useState3(autoCheck);
+  const [error, setError] = useState3(null);
+  const checkAuth = useCallback2(async () => {
     try {
       setIsLoading(true);
       setError(null);
-      const { user: user2 } = await client.admin.me();
-      setUser(user2);
+      const { data, error: apiError } = await client.admin.me();
+      if (apiError) {
+        throw apiError;
+      }
+      setUser(data.user);
     } catch (err) {
       setUser(null);
       setError(err);
@@ -534,14 +895,20 @@ function useAdminAuth(options = {}) {
       setIsLoading(false);
     }
   }, [client]);
-  const login = useCallback(
+  const login = useCallback2(
     async (email, password) => {
       try {
         setIsLoading(true);
         setError(null);
-        const response = await client.admin.login({ email, password });
-        setUser(response.user);
-        return response;
+        const { data, error: apiError } = await client.admin.login({
+          email,
+          password
+        });
+        if (apiError) {
+          throw apiError;
+        }
+        setUser(data.user);
+        return data;
       } catch (err) {
         setError(err);
         throw err;
@@ -551,7 +918,7 @@ function useAdminAuth(options = {}) {
     },
     [client]
   );
-  const logout = useCallback(async () => {
+  const logout = useCallback2(async () => {
     try {
       setIsLoading(true);
       setError(null);
@@ -563,10 +930,10 @@ function useAdminAuth(options = {}) {
       setIsLoading(false);
     }
   }, []);
-  const refresh = useCallback(async () => {
+  const refresh = useCallback2(async () => {
     await checkAuth();
   }, [checkAuth]);
-  useEffect2(() => {
+  useEffect3(() => {
     if (autoCheck) {
       checkAuth();
     }
@@ -583,60 +950,67 @@ function useAdminAuth(options = {}) {
 }
 
 // src/use-users.ts
-import { useState as useState2, useEffect as useEffect3, useCallback as useCallback2 } from "react";
+import { useState as useState4, useEffect as useEffect4, useCallback as useCallback3 } from "react";
 function useUsers(options = {}) {
   const { autoFetch = true, refetchInterval = 0, ...listOptions } = options;
   const client = useFluxbaseClient();
-  const [users, setUsers] = useState2([]);
-  const [total, setTotal] = useState2(0);
-  const [isLoading, setIsLoading] = useState2(autoFetch);
-  const [error, setError] = useState2(null);
-  const fetchUsers = useCallback2(async () => {
+  const [users, setUsers] = useState4([]);
+  const [total, setTotal] = useState4(0);
+  const [isLoading, setIsLoading] = useState4(autoFetch);
+  const [error, setError] = useState4(null);
+  const fetchUsers = useCallback3(async () => {
     try {
       setIsLoading(true);
       setError(null);
-      const response = await client.admin.listUsers(listOptions);
-      setUsers(response.users);
-      setTotal(response.total);
+      const { data, error: apiError } = await client.admin.listUsers(listOptions);
+      if (apiError) {
+        throw apiError;
+      }
+      setUsers(data.users);
+      setTotal(data.total);
     } catch (err) {
       setError(err);
     } finally {
       setIsLoading(false);
     }
   }, [client, JSON.stringify(listOptions)]);
-  const inviteUser = useCallback2(
+  const inviteUser = useCallback3(
     async (email, role) => {
       await client.admin.inviteUser({ email, role });
       await fetchUsers();
     },
     [client, fetchUsers]
   );
-  const updateUserRole = useCallback2(
+  const updateUserRole = useCallback3(
     async (userId, role) => {
       await client.admin.updateUserRole(userId, role);
       await fetchUsers();
     },
     [client, fetchUsers]
   );
-  const deleteUser = useCallback2(
+  const deleteUser = useCallback3(
     async (userId) => {
       await client.admin.deleteUser(userId);
       await fetchUsers();
     },
     [client, fetchUsers]
   );
-  const resetPassword = useCallback2(
+  const resetPassword = useCallback3(
     async (userId) => {
-      return await client.admin.resetUserPassword(userId);
+      const { data, error: error2 } = await client.admin.resetUserPassword(userId);
+      if (error2) {
+        throw error2;
+      }
+      return data;
     },
     [client]
   );
-  useEffect3(() => {
+  useEffect4(() => {
     if (autoFetch) {
       fetchUsers();
     }
   }, [autoFetch, fetchUsers]);
-  useEffect3(() => {
+  useEffect4(() => {
     if (refetchInterval > 0) {
       const interval = setInterval(fetchUsers, refetchInterval);
       return () => clearInterval(interval);
@@ -655,56 +1029,56 @@ function useUsers(options = {}) {
   };
 }
 
-// src/use-api-keys.ts
-import { useState as useState3, useEffect as useEffect4, useCallback as useCallback3 } from "react";
-function useAPIKeys(options = {}) {
+// src/use-client-keys.ts
+import { useState as useState5, useEffect as useEffect5, useCallback as useCallback4 } from "react";
+function useClientKeys(options = {}) {
   const { autoFetch = true } = options;
   const client = useFluxbaseClient();
-  const [keys, setKeys] = useState3([]);
-  const [isLoading, setIsLoading] = useState3(autoFetch);
-  const [error, setError] = useState3(null);
-  const fetchKeys = useCallback3(async () => {
+  const [keys, setKeys] = useState5([]);
+  const [isLoading, setIsLoading] = useState5(autoFetch);
+  const [error, setError] = useState5(null);
+  const fetchKeys = useCallback4(async () => {
     try {
       setIsLoading(true);
       setError(null);
-      const response = await client.admin.management.apiKeys.list();
-      setKeys(response.api_keys);
+      const response = await client.admin.management.clientKeys.list();
+      setKeys(response.client_keys);
     } catch (err) {
       setError(err);
     } finally {
       setIsLoading(false);
     }
   }, [client]);
-  const createKey = useCallback3(
+  const createKey = useCallback4(
     async (request) => {
-      const response = await client.admin.management.apiKeys.create(request);
+      const response = await client.admin.management.clientKeys.create(request);
       await fetchKeys();
-      return { key: response.key, keyData: response.api_key };
+      return { key: response.key, keyData: response.client_key };
     },
     [client, fetchKeys]
   );
-  const updateKey = useCallback3(
+  const updateKey = useCallback4(
     async (keyId, update) => {
-      await client.admin.management.apiKeys.update(keyId, update);
+      await client.admin.management.clientKeys.update(keyId, update);
       await fetchKeys();
     },
     [client, fetchKeys]
   );
-  const revokeKey = useCallback3(
+  const revokeKey = useCallback4(
     async (keyId) => {
-      await client.admin.management.apiKeys.revoke(keyId);
+      await client.admin.management.clientKeys.revoke(keyId);
       await fetchKeys();
     },
     [client, fetchKeys]
   );
-  const deleteKey = useCallback3(
+  const deleteKey = useCallback4(
     async (keyId) => {
-      await client.admin.management.apiKeys.delete(keyId);
+      await client.admin.management.clientKeys.delete(keyId);
       await fetchKeys();
     },
     [client, fetchKeys]
   );
-  useEffect4(() => {
+  useEffect5(() => {
     if (autoFetch) {
       fetchKeys();
     }
@@ -720,16 +1094,17 @@ function useAPIKeys(options = {}) {
     deleteKey
   };
 }
+var useAPIKeys = useClientKeys;
 
 // src/use-admin-hooks.ts
-import { useState as useState4, useEffect as useEffect5, useCallback as useCallback4 } from "react";
+import { useState as useState6, useEffect as useEffect6, useCallback as useCallback5 } from "react";
 function useAppSettings(options = {}) {
   const { autoFetch = true } = options;
   const client = useFluxbaseClient();
-  const [settings, setSettings] = useState4(null);
-  const [isLoading, setIsLoading] = useState4(autoFetch);
-  const [error, setError] = useState4(null);
-  const fetchSettings = useCallback4(async () => {
+  const [settings, setSettings] = useState6(null);
+  const [isLoading, setIsLoading] = useState6(autoFetch);
+  const [error, setError] = useState6(null);
+  const fetchSettings = useCallback5(async () => {
     try {
       setIsLoading(true);
       setError(null);
@@ -741,14 +1116,14 @@ function useAppSettings(options = {}) {
       setIsLoading(false);
     }
   }, [client]);
-  const updateSettings = useCallback4(
+  const updateSettings = useCallback5(
     async (update) => {
       await client.admin.settings.app.update(update);
       await fetchSettings();
     },
     [client, fetchSettings]
   );
-  useEffect5(() => {
+  useEffect6(() => {
     if (autoFetch) {
       fetchSettings();
     }
@@ -764,10 +1139,10 @@ function useAppSettings(options = {}) {
 function useSystemSettings(options = {}) {
   const { autoFetch = true } = options;
   const client = useFluxbaseClient();
-  const [settings, setSettings] = useState4([]);
-  const [isLoading, setIsLoading] = useState4(autoFetch);
-  const [error, setError] = useState4(null);
-  const fetchSettings = useCallback4(async () => {
+  const [settings, setSettings] = useState6([]);
+  const [isLoading, setIsLoading] = useState6(autoFetch);
+  const [error, setError] = useState6(null);
+  const fetchSettings = useCallback5(async () => {
     try {
       setIsLoading(true);
       setError(null);
@@ -779,27 +1154,27 @@ function useSystemSettings(options = {}) {
       setIsLoading(false);
     }
   }, [client]);
-  const getSetting = useCallback4(
+  const getSetting = useCallback5(
     (key) => {
       return settings.find((s) => s.key === key);
     },
     [settings]
   );
-  const updateSetting = useCallback4(
+  const updateSetting = useCallback5(
     async (key, update) => {
       await client.admin.settings.system.update(key, update);
       await fetchSettings();
     },
     [client, fetchSettings]
   );
-  const deleteSetting = useCallback4(
+  const deleteSetting = useCallback5(
     async (key) => {
       await client.admin.settings.system.delete(key);
       await fetchSettings();
     },
     [client, fetchSettings]
   );
-  useEffect5(() => {
+  useEffect6(() => {
     if (autoFetch) {
       fetchSettings();
     }
@@ -817,10 +1192,10 @@ function useSystemSettings(options = {}) {
 function useWebhooks(options = {}) {
   const { autoFetch = true, refetchInterval = 0 } = options;
   const client = useFluxbaseClient();
-  const [webhooks, setWebhooks] = useState4([]);
-  const [isLoading, setIsLoading] = useState4(autoFetch);
-  const [error, setError] = useState4(null);
-  const fetchWebhooks = useCallback4(async () => {
+  const [webhooks, setWebhooks] = useState6([]);
+  const [isLoading, setIsLoading] = useState6(autoFetch);
+  const [error, setError] = useState6(null);
+  const fetchWebhooks = useCallback5(async () => {
     try {
       setIsLoading(true);
       setError(null);
@@ -832,7 +1207,7 @@ function useWebhooks(options = {}) {
       setIsLoading(false);
     }
   }, [client]);
-  const createWebhook = useCallback4(
+  const createWebhook = useCallback5(
     async (webhook) => {
       const created = await client.admin.management.webhooks.create(webhook);
       await fetchWebhooks();
@@ -840,7 +1215,7 @@ function useWebhooks(options = {}) {
     },
     [client, fetchWebhooks]
   );
-  const updateWebhook = useCallback4(
+  const updateWebhook = useCallback5(
     async (id, update) => {
       const updated = await client.admin.management.webhooks.update(id, update);
       await fetchWebhooks();
@@ -848,20 +1223,20 @@ function useWebhooks(options = {}) {
     },
     [client, fetchWebhooks]
   );
-  const deleteWebhook = useCallback4(
+  const deleteWebhook = useCallback5(
     async (id) => {
       await client.admin.management.webhooks.delete(id);
       await fetchWebhooks();
     },
     [client, fetchWebhooks]
   );
-  const testWebhook = useCallback4(
+  const testWebhook = useCallback5(
     async (id) => {
       await client.admin.management.webhooks.test(id);
     },
     [client]
   );
-  useEffect5(() => {
+  useEffect6(() => {
     if (autoFetch) {
       fetchWebhooks();
     }
@@ -883,22 +1258,33 @@ function useWebhooks(options = {}) {
 }
 export {
   FluxbaseProvider,
+  isCaptchaRequiredForEndpoint,
   useAPIKeys,
   useAdminAuth,
   useAppSettings,
   useAuth,
+  useAuthConfig,
+  useCaptcha,
+  useCaptchaConfig,
+  useClientKeys,
   useCreateBucket,
   useDelete,
   useDeleteBucket,
   useFluxbaseClient,
   useFluxbaseQuery,
+  useGetSAMLLoginUrl,
+  useGraphQL,
+  useGraphQLIntrospection,
+  useGraphQLMutation,
+  useGraphQLQuery,
+  useHandleSAMLCallback,
   useInsert,
-  useRPC,
-  useRPCBatch,
-  useRPCMutation,
   useRealtime,
+  useSAMLMetadataUrl,
+  useSAMLProviders,
   useSession,
   useSignIn,
+  useSignInWithSAML,
   useSignOut,
   useSignUp,
   useStorageBuckets,
@@ -909,7 +1295,10 @@ export {
   useStorageMove,
   useStoragePublicUrl,
   useStorageSignedUrl,
+  useStorageSignedUrlWithOptions,
+  useStorageTransformUrl,
   useStorageUpload,
+  useStorageUploadWithProgress,
   useSystemSettings,
   useTable,
   useTableDeletes,