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

package/dist/index.js

@@ -21,22 +21,33 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var index_exports = {};
 __export(index_exports, {
   FluxbaseProvider: () => FluxbaseProvider,
+  isCaptchaRequiredForEndpoint: () => isCaptchaRequiredForEndpoint,
   useAPIKeys: () => useAPIKeys,
   useAdminAuth: () => useAdminAuth,
   useAppSettings: () => useAppSettings,
   useAuth: () => useAuth,
+  useAuthConfig: () => useAuthConfig,
+  useCaptcha: () => useCaptcha,
+  useCaptchaConfig: () => useCaptchaConfig,
+  useClientKeys: () => useClientKeys,
   useCreateBucket: () => useCreateBucket,
   useDelete: () => useDelete,
   useDeleteBucket: () => useDeleteBucket,
   useFluxbaseClient: () => useFluxbaseClient,
   useFluxbaseQuery: () => useFluxbaseQuery,
+  useGetSAMLLoginUrl: () => useGetSAMLLoginUrl,
+  useGraphQL: () => useGraphQL,
+  useGraphQLIntrospection: () => useGraphQLIntrospection,
+  useGraphQLMutation: () => useGraphQLMutation,
+  useGraphQLQuery: () => useGraphQLQuery,
+  useHandleSAMLCallback: () => useHandleSAMLCallback,
   useInsert: () => useInsert,
-  useRPC: () => useRPC,
-  useRPCBatch: () => useRPCBatch,
-  useRPCMutation: () => useRPCMutation,
   useRealtime: () => useRealtime,
+  useSAMLMetadataUrl: () => useSAMLMetadataUrl,
+  useSAMLProviders: () => useSAMLProviders,
   useSession: () => useSession,
   useSignIn: () => useSignIn,
+  useSignInWithSAML: () => useSignInWithSAML,
   useSignOut: () => useSignOut,
   useSignUp: () => useSignUp,
   useStorageBuckets: () => useStorageBuckets,
@@ -47,7 +58,10 @@ __export(index_exports, {
   useStorageMove: () => useStorageMove,
   useStoragePublicUrl: () => useStoragePublicUrl,
   useStorageSignedUrl: () => useStorageSignedUrl,
+  useStorageSignedUrlWithOptions: () => useStorageSignedUrlWithOptions,
+  useStorageTransformUrl: () => useStorageTransformUrl,
   useStorageUpload: () => useStorageUpload,
+  useStorageUploadWithProgress: () => useStorageUploadWithProgress,
   useSystemSettings: () => useSystemSettings,
   useTable: () => useTable,
   useTableDeletes: () => useTableDeletes,
@@ -85,12 +99,13 @@ function useUser() {
   return (0, import_react_query.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;
       }
@@ -103,7 +118,10 @@ function useSession() {
   const client = useFluxbaseClient();
   return (0, import_react_query.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
   });
@@ -130,9 +148,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
+        );
+      }
     }
   });
 }
@@ -185,12 +211,303 @@ function useAuth() {
   };
 }
 
-// src/use-query.ts
+// src/use-captcha.ts
 var import_react_query2 = require("@tanstack/react-query");
+var import_react2 = require("react");
+function useCaptchaConfig() {
+  const client = useFluxbaseClient();
+  return (0, import_react_query2.useQuery)({
+    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] = (0, import_react2.useState)(null);
+  const [isReady, setIsReady] = (0, import_react2.useState)(false);
+  const [isLoading, setIsLoading] = (0, import_react2.useState)(false);
+  const [error, setError] = (0, import_react2.useState)(null);
+  const executeResolverRef = (0, import_react2.useRef)(null);
+  const executeRejecterRef = (0, import_react2.useRef)(null);
+  const onVerify = (0, import_react2.useCallback)((newToken) => {
+    setToken(newToken);
+    setIsLoading(false);
+    setError(null);
+    setIsReady(true);
+    if (executeResolverRef.current) {
+      executeResolverRef.current(newToken);
+      executeResolverRef.current = null;
+      executeRejecterRef.current = null;
+    }
+  }, []);
+  const onExpire = (0, import_react2.useCallback)(() => {
+    setToken(null);
+    setIsReady(true);
+  }, []);
+  const onError = (0, import_react2.useCallback)((err) => {
+    setError(err);
+    setIsLoading(false);
+    setToken(null);
+    if (executeRejecterRef.current) {
+      executeRejecterRef.current(err);
+      executeResolverRef.current = null;
+      executeRejecterRef.current = null;
+    }
+  }, []);
+  const reset = (0, import_react2.useCallback)(() => {
+    setToken(null);
+    setError(null);
+    setIsLoading(false);
+  }, []);
+  const execute = (0, import_react2.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]);
+  (0, import_react2.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
+var import_react_query3 = require("@tanstack/react-query");
+function useAuthConfig() {
+  const client = useFluxbaseClient();
+  return (0, import_react_query3.useQuery)({
+    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
+var import_react_query4 = require("@tanstack/react-query");
+function useSAMLProviders() {
+  const client = useFluxbaseClient();
+  return (0, import_react_query4.useQuery)({
+    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 (0, import_react_query4.useMutation)({
+    mutationFn: async ({
+      provider,
+      options
+    }) => {
+      return await client.auth.getSAMLLoginUrl(provider, options);
+    }
+  });
+}
+function useSignInWithSAML() {
+  const client = useFluxbaseClient();
+  return (0, import_react_query4.useMutation)({
+    mutationFn: async ({
+      provider,
+      options
+    }) => {
+      return await client.auth.signInWithSAML(provider, options);
+    }
+  });
+}
+function useHandleSAMLCallback() {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query4.useQueryClient)();
+  return (0, import_react_query4.useMutation)({
+    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
+var import_react_query5 = require("@tanstack/react-query");
+function useGraphQLQuery(queryKey, query, options) {
+  const client = useFluxbaseClient();
+  const normalizedKey = Array.isArray(queryKey) ? ["fluxbase", "graphql", ...queryKey] : ["fluxbase", "graphql", queryKey];
+  return (0, import_react_query5.useQuery)({
+    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 = (0, import_react_query5.useQueryClient)();
+  return (0, import_react_query5.useMutation)({
+    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 (0, import_react_query5.useQuery)({
+    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
+var import_react_query6 = require("@tanstack/react-query");
 function useFluxbaseQuery(buildQuery, options) {
   const client = useFluxbaseClient();
   const queryKey = options?.queryKey || ["fluxbase", "query", buildQuery.toString()];
-  return (0, import_react_query2.useQuery)({
+  return (0, import_react_query6.useQuery)({
     queryKey,
     queryFn: async () => {
       const query = buildQuery(client);
@@ -218,8 +535,8 @@ function useTable(table, buildQuery, options) {
 }
 function useInsert(table) {
   const client = useFluxbaseClient();
-  const queryClient = (0, import_react_query2.useQueryClient)();
-  return (0, import_react_query2.useMutation)({
+  const queryClient = (0, import_react_query6.useQueryClient)();
+  return (0, import_react_query6.useMutation)({
     mutationFn: async (data) => {
       const query = client.from(table);
       const { data: result, error } = await query.insert(data);
@@ -235,8 +552,8 @@ function useInsert(table) {
 }
 function useUpdate(table) {
   const client = useFluxbaseClient();
-  const queryClient = (0, import_react_query2.useQueryClient)();
-  return (0, import_react_query2.useMutation)({
+  const queryClient = (0, import_react_query6.useQueryClient)();
+  return (0, import_react_query6.useMutation)({
     mutationFn: async (params) => {
       const query = client.from(table);
       const builtQuery = params.buildQuery(query);
@@ -253,8 +570,8 @@ function useUpdate(table) {
 }
 function useUpsert(table) {
   const client = useFluxbaseClient();
-  const queryClient = (0, import_react_query2.useQueryClient)();
-  return (0, import_react_query2.useMutation)({
+  const queryClient = (0, import_react_query6.useQueryClient)();
+  return (0, import_react_query6.useMutation)({
     mutationFn: async (data) => {
       const query = client.from(table);
       const { data: result, error } = await query.upsert(data);
@@ -270,8 +587,8 @@ function useUpsert(table) {
 }
 function useDelete(table) {
   const client = useFluxbaseClient();
-  const queryClient = (0, import_react_query2.useQueryClient)();
-  return (0, import_react_query2.useMutation)({
+  const queryClient = (0, import_react_query6.useQueryClient)();
+  return (0, import_react_query6.useMutation)({
     mutationFn: async (buildQuery) => {
       const query = client.from(table);
       const builtQuery = buildQuery(query);
@@ -287,12 +604,14 @@ function useDelete(table) {
 }
 
 // src/use-realtime.ts
-var import_react2 = require("react");
-var import_react_query3 = require("@tanstack/react-query");
+var import_react3 = require("react");
+var import_react_query7 = require("@tanstack/react-query");
 function useRealtime(options) {
   const client = useFluxbaseClient();
-  const queryClient = (0, import_react_query3.useQueryClient)();
-  const channelRef = (0, import_react2.useRef)(null);
+  const queryClient = (0, import_react_query7.useQueryClient)();
+  const channelRef = (0, import_react3.useRef)(
+    null
+  );
   const {
     channel: channelName,
     event = "*",
@@ -301,7 +620,7 @@ function useRealtime(options) {
     invalidateKey,
     enabled = true
   } = options;
-  (0, import_react2.useEffect)(() => {
+  (0, import_react3.useEffect)(() => {
     if (!enabled) {
       return;
     }
@@ -322,7 +641,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
   };
@@ -359,12 +687,19 @@ function useTableDeletes(table, callback, options) {
 }
 
 // src/use-storage.ts
-var import_react_query4 = require("@tanstack/react-query");
+var import_react4 = require("react");
+var import_react_query8 = require("@tanstack/react-query");
 function useStorageList(bucket, options) {
   const client = useFluxbaseClient();
   const { prefix, limit, offset, ...queryOptions } = options || {};
-  return (0, import_react_query4.useQuery)({
-    queryKey: ["fluxbase", "storage", bucket, "list", { prefix, limit, offset }],
+  return (0, import_react_query8.useQuery)({
+    queryKey: [
+      "fluxbase",
+      "storage",
+      bucket,
+      "list",
+      { prefix, limit, offset }
+    ],
     queryFn: async () => {
       const { data, error } = await client.storage.from(bucket).list({ prefix, limit, offset });
       if (error) {
@@ -377,8 +712,8 @@ function useStorageList(bucket, options) {
 }
 function useStorageUpload(bucket) {
   const client = useFluxbaseClient();
-  const queryClient = (0, import_react_query4.useQueryClient)();
-  return (0, import_react_query4.useMutation)({
+  const queryClient = (0, import_react_query8.useQueryClient)();
+  return (0, import_react_query8.useMutation)({
     mutationFn: async (params) => {
       const { path, file, options } = params;
       const { data, error } = await client.storage.from(bucket).upload(path, file, options);
@@ -388,13 +723,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 = (0, import_react_query8.useQueryClient)();
+  const [progress, setProgress] = (0, import_react4.useState)(null);
+  const mutation = (0, import_react_query8.useMutation)({
+    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 (0, import_react_query4.useQuery)({
+  return (0, import_react_query8.useQuery)({
     queryKey: ["fluxbase", "storage", bucket, "download", path],
     queryFn: async () => {
       if (!path) {
@@ -411,8 +782,8 @@ function useStorageDownload(bucket, path, enabled = true) {
 }
 function useStorageDelete(bucket) {
   const client = useFluxbaseClient();
-  const queryClient = (0, import_react_query4.useQueryClient)();
-  return (0, import_react_query4.useMutation)({
+  const queryClient = (0, import_react_query8.useQueryClient)();
+  return (0, import_react_query8.useMutation)({
     mutationFn: async (paths) => {
       const { error } = await client.storage.from(bucket).remove(paths);
       if (error) {
@@ -420,7 +791,9 @@ function useStorageDelete(bucket) {
       }
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", bucket, "list"] });
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "storage", bucket, "list"]
+      });
     }
   });
 }
@@ -432,9 +805,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 (0, import_react_query4.useQuery)({
+  return (0, import_react_query8.useQuery)({
     queryKey: ["fluxbase", "storage", bucket, "signed-url", path, expiresIn],
     queryFn: async () => {
       if (!path) {
@@ -451,10 +831,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 (0, import_react_query8.useQuery)({
+    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 = (0, import_react_query4.useQueryClient)();
-  return (0, import_react_query4.useMutation)({
+  const queryClient = (0, import_react_query8.useQueryClient)();
+  return (0, import_react_query8.useMutation)({
     mutationFn: async (params) => {
       const { fromPath, toPath } = params;
       const { data, error } = await client.storage.from(bucket).move(fromPath, toPath);
@@ -464,14 +873,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 = (0, import_react_query4.useQueryClient)();
-  return (0, import_react_query4.useMutation)({
+  const queryClient = (0, import_react_query8.useQueryClient)();
+  return (0, import_react_query8.useMutation)({
     mutationFn: async (params) => {
       const { fromPath, toPath } = params;
       const { data, error } = await client.storage.from(bucket).copy(fromPath, toPath);
@@ -481,13 +892,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 (0, import_react_query4.useQuery)({
+  return (0, import_react_query8.useQuery)({
     queryKey: ["fluxbase", "storage", "buckets"],
     queryFn: async () => {
       const { data, error } = await client.storage.listBuckets();
@@ -500,8 +913,8 @@ function useStorageBuckets() {
 }
 function useCreateBucket() {
   const client = useFluxbaseClient();
-  const queryClient = (0, import_react_query4.useQueryClient)();
-  return (0, import_react_query4.useMutation)({
+  const queryClient = (0, import_react_query8.useQueryClient)();
+  return (0, import_react_query8.useMutation)({
     mutationFn: async (bucketName) => {
       const { error } = await client.storage.createBucket(bucketName);
       if (error) {
@@ -509,14 +922,16 @@ function useCreateBucket() {
       }
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", "buckets"] });
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "storage", "buckets"]
+      });
     }
   });
 }
 function useDeleteBucket() {
   const client = useFluxbaseClient();
-  const queryClient = (0, import_react_query4.useQueryClient)();
-  return (0, import_react_query4.useMutation)({
+  const queryClient = (0, import_react_query8.useQueryClient)();
+  return (0, import_react_query8.useMutation)({
     mutationFn: async (bucketName) => {
       const { error } = await client.storage.deleteBucket(bucketName);
       if (error) {
@@ -524,74 +939,30 @@ function useDeleteBucket() {
       }
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", "buckets"] });
+      queryClient.invalidateQueries({
+        queryKey: ["fluxbase", "storage", "buckets"]
+      });
     }
   });
 }
 
-// src/use-rpc.ts
-var import_react_query5 = require("@tanstack/react-query");
-function useRPC(functionName, params, options) {
-  const client = useFluxbaseClient();
-  return (0, import_react_query5.useQuery)({
-    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 (0, import_react_query5.useMutation)({
-    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 (0, import_react_query5.useQuery)({
-    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
-var import_react3 = require("react");
+var import_react5 = require("react");
 function useAdminAuth(options = {}) {
   const { autoCheck = true } = options;
   const client = useFluxbaseClient();
-  const [user, setUser] = (0, import_react3.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react3.useState)(autoCheck);
-  const [error, setError] = (0, import_react3.useState)(null);
-  const checkAuth = (0, import_react3.useCallback)(async () => {
+  const [user, setUser] = (0, import_react5.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react5.useState)(autoCheck);
+  const [error, setError] = (0, import_react5.useState)(null);
+  const checkAuth = (0, import_react5.useCallback)(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);
@@ -599,14 +970,20 @@ function useAdminAuth(options = {}) {
       setIsLoading(false);
     }
   }, [client]);
-  const login = (0, import_react3.useCallback)(
+  const login = (0, import_react5.useCallback)(
     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;
@@ -616,7 +993,7 @@ function useAdminAuth(options = {}) {
     },
     [client]
   );
-  const logout = (0, import_react3.useCallback)(async () => {
+  const logout = (0, import_react5.useCallback)(async () => {
     try {
       setIsLoading(true);
       setError(null);
@@ -628,10 +1005,10 @@ function useAdminAuth(options = {}) {
       setIsLoading(false);
     }
   }, []);
-  const refresh = (0, import_react3.useCallback)(async () => {
+  const refresh = (0, import_react5.useCallback)(async () => {
     await checkAuth();
   }, [checkAuth]);
-  (0, import_react3.useEffect)(() => {
+  (0, import_react5.useEffect)(() => {
     if (autoCheck) {
       checkAuth();
     }
@@ -648,60 +1025,67 @@ function useAdminAuth(options = {}) {
 }
 
 // src/use-users.ts
-var import_react4 = require("react");
+var import_react6 = require("react");
 function useUsers(options = {}) {
   const { autoFetch = true, refetchInterval = 0, ...listOptions } = options;
   const client = useFluxbaseClient();
-  const [users, setUsers] = (0, import_react4.useState)([]);
-  const [total, setTotal] = (0, import_react4.useState)(0);
-  const [isLoading, setIsLoading] = (0, import_react4.useState)(autoFetch);
-  const [error, setError] = (0, import_react4.useState)(null);
-  const fetchUsers = (0, import_react4.useCallback)(async () => {
+  const [users, setUsers] = (0, import_react6.useState)([]);
+  const [total, setTotal] = (0, import_react6.useState)(0);
+  const [isLoading, setIsLoading] = (0, import_react6.useState)(autoFetch);
+  const [error, setError] = (0, import_react6.useState)(null);
+  const fetchUsers = (0, import_react6.useCallback)(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 = (0, import_react4.useCallback)(
+  const inviteUser = (0, import_react6.useCallback)(
     async (email, role) => {
       await client.admin.inviteUser({ email, role });
       await fetchUsers();
     },
     [client, fetchUsers]
   );
-  const updateUserRole = (0, import_react4.useCallback)(
+  const updateUserRole = (0, import_react6.useCallback)(
     async (userId, role) => {
       await client.admin.updateUserRole(userId, role);
       await fetchUsers();
     },
     [client, fetchUsers]
   );
-  const deleteUser = (0, import_react4.useCallback)(
+  const deleteUser = (0, import_react6.useCallback)(
     async (userId) => {
       await client.admin.deleteUser(userId);
       await fetchUsers();
     },
     [client, fetchUsers]
   );
-  const resetPassword = (0, import_react4.useCallback)(
+  const resetPassword = (0, import_react6.useCallback)(
     async (userId) => {
-      return await client.admin.resetUserPassword(userId);
+      const { data, error: error2 } = await client.admin.resetUserPassword(userId);
+      if (error2) {
+        throw error2;
+      }
+      return data;
     },
     [client]
   );
-  (0, import_react4.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     if (autoFetch) {
       fetchUsers();
     }
   }, [autoFetch, fetchUsers]);
-  (0, import_react4.useEffect)(() => {
+  (0, import_react6.useEffect)(() => {
     if (refetchInterval > 0) {
       const interval = setInterval(fetchUsers, refetchInterval);
       return () => clearInterval(interval);
@@ -720,56 +1104,56 @@ function useUsers(options = {}) {
   };
 }
 
-// src/use-api-keys.ts
-var import_react5 = require("react");
-function useAPIKeys(options = {}) {
+// src/use-client-keys.ts
+var import_react7 = require("react");
+function useClientKeys(options = {}) {
   const { autoFetch = true } = options;
   const client = useFluxbaseClient();
-  const [keys, setKeys] = (0, import_react5.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react5.useState)(autoFetch);
-  const [error, setError] = (0, import_react5.useState)(null);
-  const fetchKeys = (0, import_react5.useCallback)(async () => {
+  const [keys, setKeys] = (0, import_react7.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react7.useState)(autoFetch);
+  const [error, setError] = (0, import_react7.useState)(null);
+  const fetchKeys = (0, import_react7.useCallback)(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 = (0, import_react5.useCallback)(
+  const createKey = (0, import_react7.useCallback)(
     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 = (0, import_react5.useCallback)(
+  const updateKey = (0, import_react7.useCallback)(
     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 = (0, import_react5.useCallback)(
+  const revokeKey = (0, import_react7.useCallback)(
     async (keyId) => {
-      await client.admin.management.apiKeys.revoke(keyId);
+      await client.admin.management.clientKeys.revoke(keyId);
       await fetchKeys();
     },
     [client, fetchKeys]
   );
-  const deleteKey = (0, import_react5.useCallback)(
+  const deleteKey = (0, import_react7.useCallback)(
     async (keyId) => {
-      await client.admin.management.apiKeys.delete(keyId);
+      await client.admin.management.clientKeys.delete(keyId);
       await fetchKeys();
     },
     [client, fetchKeys]
   );
-  (0, import_react5.useEffect)(() => {
+  (0, import_react7.useEffect)(() => {
     if (autoFetch) {
       fetchKeys();
     }
@@ -785,16 +1169,17 @@ function useAPIKeys(options = {}) {
     deleteKey
   };
 }
+var useAPIKeys = useClientKeys;
 
 // src/use-admin-hooks.ts
-var import_react6 = require("react");
+var import_react8 = require("react");
 function useAppSettings(options = {}) {
   const { autoFetch = true } = options;
   const client = useFluxbaseClient();
-  const [settings, setSettings] = (0, import_react6.useState)(null);
-  const [isLoading, setIsLoading] = (0, import_react6.useState)(autoFetch);
-  const [error, setError] = (0, import_react6.useState)(null);
-  const fetchSettings = (0, import_react6.useCallback)(async () => {
+  const [settings, setSettings] = (0, import_react8.useState)(null);
+  const [isLoading, setIsLoading] = (0, import_react8.useState)(autoFetch);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const fetchSettings = (0, import_react8.useCallback)(async () => {
     try {
       setIsLoading(true);
       setError(null);
@@ -806,14 +1191,14 @@ function useAppSettings(options = {}) {
       setIsLoading(false);
     }
   }, [client]);
-  const updateSettings = (0, import_react6.useCallback)(
+  const updateSettings = (0, import_react8.useCallback)(
     async (update) => {
       await client.admin.settings.app.update(update);
       await fetchSettings();
     },
     [client, fetchSettings]
   );
-  (0, import_react6.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (autoFetch) {
       fetchSettings();
     }
@@ -829,10 +1214,10 @@ function useAppSettings(options = {}) {
 function useSystemSettings(options = {}) {
   const { autoFetch = true } = options;
   const client = useFluxbaseClient();
-  const [settings, setSettings] = (0, import_react6.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react6.useState)(autoFetch);
-  const [error, setError] = (0, import_react6.useState)(null);
-  const fetchSettings = (0, import_react6.useCallback)(async () => {
+  const [settings, setSettings] = (0, import_react8.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react8.useState)(autoFetch);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const fetchSettings = (0, import_react8.useCallback)(async () => {
     try {
       setIsLoading(true);
       setError(null);
@@ -844,27 +1229,27 @@ function useSystemSettings(options = {}) {
       setIsLoading(false);
     }
   }, [client]);
-  const getSetting = (0, import_react6.useCallback)(
+  const getSetting = (0, import_react8.useCallback)(
     (key) => {
       return settings.find((s) => s.key === key);
     },
     [settings]
   );
-  const updateSetting = (0, import_react6.useCallback)(
+  const updateSetting = (0, import_react8.useCallback)(
     async (key, update) => {
       await client.admin.settings.system.update(key, update);
       await fetchSettings();
     },
     [client, fetchSettings]
   );
-  const deleteSetting = (0, import_react6.useCallback)(
+  const deleteSetting = (0, import_react8.useCallback)(
     async (key) => {
       await client.admin.settings.system.delete(key);
       await fetchSettings();
     },
     [client, fetchSettings]
   );
-  (0, import_react6.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (autoFetch) {
       fetchSettings();
     }
@@ -882,10 +1267,10 @@ function useSystemSettings(options = {}) {
 function useWebhooks(options = {}) {
   const { autoFetch = true, refetchInterval = 0 } = options;
   const client = useFluxbaseClient();
-  const [webhooks, setWebhooks] = (0, import_react6.useState)([]);
-  const [isLoading, setIsLoading] = (0, import_react6.useState)(autoFetch);
-  const [error, setError] = (0, import_react6.useState)(null);
-  const fetchWebhooks = (0, import_react6.useCallback)(async () => {
+  const [webhooks, setWebhooks] = (0, import_react8.useState)([]);
+  const [isLoading, setIsLoading] = (0, import_react8.useState)(autoFetch);
+  const [error, setError] = (0, import_react8.useState)(null);
+  const fetchWebhooks = (0, import_react8.useCallback)(async () => {
     try {
       setIsLoading(true);
       setError(null);
@@ -897,7 +1282,7 @@ function useWebhooks(options = {}) {
       setIsLoading(false);
     }
   }, [client]);
-  const createWebhook = (0, import_react6.useCallback)(
+  const createWebhook = (0, import_react8.useCallback)(
     async (webhook) => {
       const created = await client.admin.management.webhooks.create(webhook);
       await fetchWebhooks();
@@ -905,7 +1290,7 @@ function useWebhooks(options = {}) {
     },
     [client, fetchWebhooks]
   );
-  const updateWebhook = (0, import_react6.useCallback)(
+  const updateWebhook = (0, import_react8.useCallback)(
     async (id, update) => {
       const updated = await client.admin.management.webhooks.update(id, update);
       await fetchWebhooks();
@@ -913,20 +1298,20 @@ function useWebhooks(options = {}) {
     },
     [client, fetchWebhooks]
   );
-  const deleteWebhook = (0, import_react6.useCallback)(
+  const deleteWebhook = (0, import_react8.useCallback)(
     async (id) => {
       await client.admin.management.webhooks.delete(id);
       await fetchWebhooks();
     },
     [client, fetchWebhooks]
   );
-  const testWebhook = (0, import_react6.useCallback)(
+  const testWebhook = (0, import_react8.useCallback)(
     async (id) => {
       await client.admin.management.webhooks.test(id);
     },
     [client]
   );
-  (0, import_react6.useEffect)(() => {
+  (0, import_react8.useEffect)(() => {
     if (autoFetch) {
       fetchWebhooks();
     }
@@ -949,22 +1334,33 @@ function useWebhooks(options = {}) {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   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,
@@ -975,7 +1371,10 @@ function useWebhooks(options = {}) {
   useStorageMove,
   useStoragePublicUrl,
   useStorageSignedUrl,
+  useStorageSignedUrlWithOptions,
+  useStorageTransformUrl,
   useStorageUpload,
+  useStorageUploadWithProgress,
   useSystemSettings,
   useTable,
   useTableDeletes,