@fluxbase/sdk-react 0.0.1-rc.2

package/dist/index.js

@@ -0,0 +1,992 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  FluxbaseProvider: () => FluxbaseProvider,
+  useAPIKeys: () => useAPIKeys,
+  useAdminAuth: () => useAdminAuth,
+  useAppSettings: () => useAppSettings,
+  useAuth: () => useAuth,
+  useCreateBucket: () => useCreateBucket,
+  useDelete: () => useDelete,
+  useDeleteBucket: () => useDeleteBucket,
+  useFluxbaseClient: () => useFluxbaseClient,
+  useFluxbaseQuery: () => useFluxbaseQuery,
+  useInsert: () => useInsert,
+  useRPC: () => useRPC,
+  useRPCBatch: () => useRPCBatch,
+  useRPCMutation: () => useRPCMutation,
+  useRealtime: () => useRealtime,
+  useSession: () => useSession,
+  useSignIn: () => useSignIn,
+  useSignOut: () => useSignOut,
+  useSignUp: () => useSignUp,
+  useStorageBuckets: () => useStorageBuckets,
+  useStorageCopy: () => useStorageCopy,
+  useStorageDelete: () => useStorageDelete,
+  useStorageDownload: () => useStorageDownload,
+  useStorageList: () => useStorageList,
+  useStorageMove: () => useStorageMove,
+  useStoragePublicUrl: () => useStoragePublicUrl,
+  useStorageSignedUrl: () => useStorageSignedUrl,
+  useStorageUpload: () => useStorageUpload,
+  useSystemSettings: () => useSystemSettings,
+  useTable: () => useTable,
+  useTableDeletes: () => useTableDeletes,
+  useTableInserts: () => useTableInserts,
+  useTableSubscription: () => useTableSubscription,
+  useTableUpdates: () => useTableUpdates,
+  useUpdate: () => useUpdate,
+  useUpdateUser: () => useUpdateUser,
+  useUpsert: () => useUpsert,
+  useUser: () => useUser,
+  useUsers: () => useUsers,
+  useWebhooks: () => useWebhooks
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/context.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var FluxbaseContext = (0, import_react.createContext)(null);
+function FluxbaseProvider({ client, children }) {
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(FluxbaseContext.Provider, { value: client, children });
+}
+function useFluxbaseClient() {
+  const client = (0, import_react.useContext)(FluxbaseContext);
+  if (!client) {
+    throw new Error("useFluxbaseClient must be used within a FluxbaseProvider");
+  }
+  return client;
+}
+
+// src/use-auth.ts
+var import_react_query = require("@tanstack/react-query");
+function useUser() {
+  const client = useFluxbaseClient();
+  return (0, import_react_query.useQuery)({
+    queryKey: ["fluxbase", "auth", "user"],
+    queryFn: async () => {
+      const session = client.auth.getSession();
+      if (!session) {
+        return null;
+      }
+      try {
+        return await client.auth.getCurrentUser();
+      } catch {
+        return null;
+      }
+    },
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+}
+function useSession() {
+  const client = useFluxbaseClient();
+  return (0, import_react_query.useQuery)({
+    queryKey: ["fluxbase", "auth", "session"],
+    queryFn: () => client.auth.getSession(),
+    staleTime: 1e3 * 60 * 5
+    // 5 minutes
+  });
+}
+function useSignIn() {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query.useQueryClient)();
+  return (0, import_react_query.useMutation)({
+    mutationFn: async (credentials) => {
+      return await client.auth.signIn(credentials);
+    },
+    onSuccess: (session) => {
+      queryClient.setQueryData(["fluxbase", "auth", "session"], session);
+      if ("user" in session) {
+        queryClient.setQueryData(["fluxbase", "auth", "user"], session.user);
+      }
+    }
+  });
+}
+function useSignUp() {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query.useQueryClient)();
+  return (0, import_react_query.useMutation)({
+    mutationFn: async (credentials) => {
+      return await client.auth.signUp(credentials);
+    },
+    onSuccess: (session) => {
+      queryClient.setQueryData(["fluxbase", "auth", "session"], session);
+      queryClient.setQueryData(["fluxbase", "auth", "user"], session.user);
+    }
+  });
+}
+function useSignOut() {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query.useQueryClient)();
+  return (0, import_react_query.useMutation)({
+    mutationFn: async () => {
+      await client.auth.signOut();
+    },
+    onSuccess: () => {
+      queryClient.setQueryData(["fluxbase", "auth", "session"], null);
+      queryClient.setQueryData(["fluxbase", "auth", "user"], null);
+      queryClient.invalidateQueries({ queryKey: ["fluxbase"] });
+    }
+  });
+}
+function useUpdateUser() {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query.useQueryClient)();
+  return (0, import_react_query.useMutation)({
+    mutationFn: async (data) => {
+      return await client.auth.updateUser(data);
+    },
+    onSuccess: (user) => {
+      queryClient.setQueryData(["fluxbase", "auth", "user"], user);
+    }
+  });
+}
+function useAuth() {
+  const { data: user, isLoading: isLoadingUser } = useUser();
+  const { data: session, isLoading: isLoadingSession } = useSession();
+  const signIn = useSignIn();
+  const signUp = useSignUp();
+  const signOut = useSignOut();
+  const updateUser = useUpdateUser();
+  return {
+    user,
+    session,
+    isLoading: isLoadingUser || isLoadingSession,
+    isAuthenticated: !!session,
+    signIn: signIn.mutateAsync,
+    signUp: signUp.mutateAsync,
+    signOut: signOut.mutateAsync,
+    updateUser: updateUser.mutateAsync,
+    isSigningIn: signIn.isPending,
+    isSigningUp: signUp.isPending,
+    isSigningOut: signOut.isPending,
+    isUpdating: updateUser.isPending
+  };
+}
+
+// src/use-query.ts
+var import_react_query2 = 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)({
+    queryKey,
+    queryFn: async () => {
+      const query = buildQuery(client);
+      const { data, error } = await query.execute();
+      if (error) {
+        throw error;
+      }
+      return Array.isArray(data) ? data : data ? [data] : [];
+    },
+    ...options
+  });
+}
+function useTable(table, buildQuery, options) {
+  const client = useFluxbaseClient();
+  return useFluxbaseQuery(
+    (client2) => {
+      const query = client2.from(table);
+      return buildQuery ? buildQuery(query) : query;
+    },
+    {
+      ...options,
+      queryKey: options?.queryKey || ["fluxbase", "table", table, buildQuery?.toString()]
+    }
+  );
+}
+function useInsert(table) {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query2.useQueryClient)();
+  return (0, import_react_query2.useMutation)({
+    mutationFn: async (data) => {
+      const query = client.from(table);
+      const { data: result, error } = await query.insert(data);
+      if (error) {
+        throw error;
+      }
+      return result;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
+    }
+  });
+}
+function useUpdate(table) {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query2.useQueryClient)();
+  return (0, import_react_query2.useMutation)({
+    mutationFn: async (params) => {
+      const query = client.from(table);
+      const builtQuery = params.buildQuery(query);
+      const { data: result, error } = await builtQuery.update(params.data);
+      if (error) {
+        throw error;
+      }
+      return result;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
+    }
+  });
+}
+function useUpsert(table) {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query2.useQueryClient)();
+  return (0, import_react_query2.useMutation)({
+    mutationFn: async (data) => {
+      const query = client.from(table);
+      const { data: result, error } = await query.upsert(data);
+      if (error) {
+        throw error;
+      }
+      return result;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
+    }
+  });
+}
+function useDelete(table) {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query2.useQueryClient)();
+  return (0, import_react_query2.useMutation)({
+    mutationFn: async (buildQuery) => {
+      const query = client.from(table);
+      const builtQuery = buildQuery(query);
+      const { error } = await builtQuery.delete();
+      if (error) {
+        throw error;
+      }
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
+    }
+  });
+}
+
+// src/use-realtime.ts
+var import_react2 = require("react");
+var import_react_query3 = 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 {
+    channel: channelName,
+    event = "*",
+    callback,
+    autoInvalidate = true,
+    invalidateKey,
+    enabled = true
+  } = options;
+  (0, import_react2.useEffect)(() => {
+    if (!enabled) {
+      return;
+    }
+    const channel = client.realtime.channel(channelName);
+    channelRef.current = channel;
+    const handleChange = (payload) => {
+      if (callback) {
+        callback(payload);
+      }
+      if (autoInvalidate) {
+        const tableName = channelName.replace(/^table:/, "");
+        const key = invalidateKey || ["fluxbase", "table", tableName];
+        queryClient.invalidateQueries({ queryKey: key });
+      }
+    };
+    channel.on(event, handleChange).subscribe();
+    return () => {
+      channel.unsubscribe();
+      channelRef.current = null;
+    };
+  }, [client, channelName, event, callback, autoInvalidate, invalidateKey, queryClient, enabled]);
+  return {
+    channel: channelRef.current
+  };
+}
+function useTableSubscription(table, options) {
+  return useRealtime({
+    ...options,
+    channel: `table:${table}`
+  });
+}
+function useTableInserts(table, callback, options) {
+  return useRealtime({
+    ...options,
+    channel: `table:${table}`,
+    event: "INSERT",
+    callback
+  });
+}
+function useTableUpdates(table, callback, options) {
+  return useRealtime({
+    ...options,
+    channel: `table:${table}`,
+    event: "UPDATE",
+    callback
+  });
+}
+function useTableDeletes(table, callback, options) {
+  return useRealtime({
+    ...options,
+    channel: `table:${table}`,
+    event: "DELETE",
+    callback
+  });
+}
+
+// src/use-storage.ts
+var import_react_query4 = 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 }],
+    queryFn: async () => {
+      const { data, error } = await client.storage.from(bucket).list({ prefix, limit, offset });
+      if (error) {
+        throw error;
+      }
+      return data || [];
+    },
+    ...queryOptions
+  });
+}
+function useStorageUpload(bucket) {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query4.useQueryClient)();
+  return (0, import_react_query4.useMutation)({
+    mutationFn: async (params) => {
+      const { path, file, options } = params;
+      const { data, error } = await client.storage.from(bucket).upload(path, file, options);
+      if (error) {
+        throw error;
+      }
+      return data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", bucket, "list"] });
+    }
+  });
+}
+function useStorageDownload(bucket, path, enabled = true) {
+  const client = useFluxbaseClient();
+  return (0, import_react_query4.useQuery)({
+    queryKey: ["fluxbase", "storage", bucket, "download", path],
+    queryFn: async () => {
+      if (!path) {
+        return null;
+      }
+      const { data, error } = await client.storage.from(bucket).download(path);
+      if (error) {
+        throw error;
+      }
+      return data;
+    },
+    enabled: enabled && !!path
+  });
+}
+function useStorageDelete(bucket) {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query4.useQueryClient)();
+  return (0, import_react_query4.useMutation)({
+    mutationFn: async (paths) => {
+      const { error } = await client.storage.from(bucket).remove(paths);
+      if (error) {
+        throw error;
+      }
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", bucket, "list"] });
+    }
+  });
+}
+function useStoragePublicUrl(bucket, path) {
+  const client = useFluxbaseClient();
+  if (!path) {
+    return null;
+  }
+  const { data } = client.storage.from(bucket).getPublicUrl(path);
+  return data.publicUrl;
+}
+function useStorageSignedUrl(bucket, path, expiresIn) {
+  const client = useFluxbaseClient();
+  return (0, import_react_query4.useQuery)({
+    queryKey: ["fluxbase", "storage", bucket, "signed-url", path, expiresIn],
+    queryFn: async () => {
+      if (!path) {
+        return null;
+      }
+      const { data, error } = await client.storage.from(bucket).createSignedUrl(path, { expiresIn });
+      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)({
+    mutationFn: async (params) => {
+      const { fromPath, toPath } = params;
+      const { data, error } = await client.storage.from(bucket).move(fromPath, toPath);
+      if (error) {
+        throw error;
+      }
+      return data;
+    },
+    onSuccess: () => {
+      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)({
+    mutationFn: async (params) => {
+      const { fromPath, toPath } = params;
+      const { data, error } = await client.storage.from(bucket).copy(fromPath, toPath);
+      if (error) {
+        throw error;
+      }
+      return data;
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", bucket, "list"] });
+    }
+  });
+}
+function useStorageBuckets() {
+  const client = useFluxbaseClient();
+  return (0, import_react_query4.useQuery)({
+    queryKey: ["fluxbase", "storage", "buckets"],
+    queryFn: async () => {
+      const { data, error } = await client.storage.listBuckets();
+      if (error) {
+        throw error;
+      }
+      return data || [];
+    }
+  });
+}
+function useCreateBucket() {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query4.useQueryClient)();
+  return (0, import_react_query4.useMutation)({
+    mutationFn: async (bucketName) => {
+      const { error } = await client.storage.createBucket(bucketName);
+      if (error) {
+        throw error;
+      }
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "storage", "buckets"] });
+    }
+  });
+}
+function useDeleteBucket() {
+  const client = useFluxbaseClient();
+  const queryClient = (0, import_react_query4.useQueryClient)();
+  return (0, import_react_query4.useMutation)({
+    mutationFn: async (bucketName) => {
+      const { error } = await client.storage.deleteBucket(bucketName);
+      if (error) {
+        throw error;
+      }
+    },
+    onSuccess: () => {
+      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");
+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 () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const { user: user2 } = await client.admin.me();
+      setUser(user2);
+    } catch (err) {
+      setUser(null);
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const login = (0, import_react3.useCallback)(
+    async (email, password) => {
+      try {
+        setIsLoading(true);
+        setError(null);
+        const response = await client.admin.login({ email, password });
+        setUser(response.user);
+        return response;
+      } catch (err) {
+        setError(err);
+        throw err;
+      } finally {
+        setIsLoading(false);
+      }
+    },
+    [client]
+  );
+  const logout = (0, import_react3.useCallback)(async () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      setUser(null);
+    } catch (err) {
+      setError(err);
+      throw err;
+    } finally {
+      setIsLoading(false);
+    }
+  }, []);
+  const refresh = (0, import_react3.useCallback)(async () => {
+    await checkAuth();
+  }, [checkAuth]);
+  (0, import_react3.useEffect)(() => {
+    if (autoCheck) {
+      checkAuth();
+    }
+  }, [autoCheck, checkAuth]);
+  return {
+    user,
+    isAuthenticated: user !== null,
+    isLoading,
+    error,
+    login,
+    logout,
+    refresh
+  };
+}
+
+// src/use-users.ts
+var import_react4 = 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 () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const response = await client.admin.listUsers(listOptions);
+      setUsers(response.users);
+      setTotal(response.total);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, JSON.stringify(listOptions)]);
+  const inviteUser = (0, import_react4.useCallback)(
+    async (email, role) => {
+      await client.admin.inviteUser({ email, role });
+      await fetchUsers();
+    },
+    [client, fetchUsers]
+  );
+  const updateUserRole = (0, import_react4.useCallback)(
+    async (userId, role) => {
+      await client.admin.updateUserRole(userId, role);
+      await fetchUsers();
+    },
+    [client, fetchUsers]
+  );
+  const deleteUser = (0, import_react4.useCallback)(
+    async (userId) => {
+      await client.admin.deleteUser(userId);
+      await fetchUsers();
+    },
+    [client, fetchUsers]
+  );
+  const resetPassword = (0, import_react4.useCallback)(
+    async (userId) => {
+      return await client.admin.resetUserPassword(userId);
+    },
+    [client]
+  );
+  (0, import_react4.useEffect)(() => {
+    if (autoFetch) {
+      fetchUsers();
+    }
+  }, [autoFetch, fetchUsers]);
+  (0, import_react4.useEffect)(() => {
+    if (refetchInterval > 0) {
+      const interval = setInterval(fetchUsers, refetchInterval);
+      return () => clearInterval(interval);
+    }
+  }, [refetchInterval, fetchUsers]);
+  return {
+    users,
+    total,
+    isLoading,
+    error,
+    refetch: fetchUsers,
+    inviteUser,
+    updateUserRole,
+    deleteUser,
+    resetPassword
+  };
+}
+
+// src/use-api-keys.ts
+var import_react5 = require("react");
+function useAPIKeys(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 () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const response = await client.admin.management.apiKeys.list();
+      setKeys(response.api_keys);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const createKey = (0, import_react5.useCallback)(
+    async (request) => {
+      const response = await client.admin.management.apiKeys.create(request);
+      await fetchKeys();
+      return { key: response.key, keyData: response.api_key };
+    },
+    [client, fetchKeys]
+  );
+  const updateKey = (0, import_react5.useCallback)(
+    async (keyId, update) => {
+      await client.admin.management.apiKeys.update(keyId, update);
+      await fetchKeys();
+    },
+    [client, fetchKeys]
+  );
+  const revokeKey = (0, import_react5.useCallback)(
+    async (keyId) => {
+      await client.admin.management.apiKeys.revoke(keyId);
+      await fetchKeys();
+    },
+    [client, fetchKeys]
+  );
+  const deleteKey = (0, import_react5.useCallback)(
+    async (keyId) => {
+      await client.admin.management.apiKeys.delete(keyId);
+      await fetchKeys();
+    },
+    [client, fetchKeys]
+  );
+  (0, import_react5.useEffect)(() => {
+    if (autoFetch) {
+      fetchKeys();
+    }
+  }, [autoFetch, fetchKeys]);
+  return {
+    keys,
+    isLoading,
+    error,
+    refetch: fetchKeys,
+    createKey,
+    updateKey,
+    revokeKey,
+    deleteKey
+  };
+}
+
+// src/use-admin-hooks.ts
+var import_react6 = 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 () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const appSettings = await client.admin.settings.app.get();
+      setSettings(appSettings);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const updateSettings = (0, import_react6.useCallback)(
+    async (update) => {
+      await client.admin.settings.app.update(update);
+      await fetchSettings();
+    },
+    [client, fetchSettings]
+  );
+  (0, import_react6.useEffect)(() => {
+    if (autoFetch) {
+      fetchSettings();
+    }
+  }, [autoFetch, fetchSettings]);
+  return {
+    settings,
+    isLoading,
+    error,
+    refetch: fetchSettings,
+    updateSettings
+  };
+}
+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 () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const response = await client.admin.settings.system.list();
+      setSettings(response.settings);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const getSetting = (0, import_react6.useCallback)(
+    (key) => {
+      return settings.find((s) => s.key === key);
+    },
+    [settings]
+  );
+  const updateSetting = (0, import_react6.useCallback)(
+    async (key, update) => {
+      await client.admin.settings.system.update(key, update);
+      await fetchSettings();
+    },
+    [client, fetchSettings]
+  );
+  const deleteSetting = (0, import_react6.useCallback)(
+    async (key) => {
+      await client.admin.settings.system.delete(key);
+      await fetchSettings();
+    },
+    [client, fetchSettings]
+  );
+  (0, import_react6.useEffect)(() => {
+    if (autoFetch) {
+      fetchSettings();
+    }
+  }, [autoFetch, fetchSettings]);
+  return {
+    settings,
+    isLoading,
+    error,
+    refetch: fetchSettings,
+    getSetting,
+    updateSetting,
+    deleteSetting
+  };
+}
+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 () => {
+    try {
+      setIsLoading(true);
+      setError(null);
+      const response = await client.admin.management.webhooks.list();
+      setWebhooks(response.webhooks);
+    } catch (err) {
+      setError(err);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client]);
+  const createWebhook = (0, import_react6.useCallback)(
+    async (webhook) => {
+      const created = await client.admin.management.webhooks.create(webhook);
+      await fetchWebhooks();
+      return created;
+    },
+    [client, fetchWebhooks]
+  );
+  const updateWebhook = (0, import_react6.useCallback)(
+    async (id, update) => {
+      const updated = await client.admin.management.webhooks.update(id, update);
+      await fetchWebhooks();
+      return updated;
+    },
+    [client, fetchWebhooks]
+  );
+  const deleteWebhook = (0, import_react6.useCallback)(
+    async (id) => {
+      await client.admin.management.webhooks.delete(id);
+      await fetchWebhooks();
+    },
+    [client, fetchWebhooks]
+  );
+  const testWebhook = (0, import_react6.useCallback)(
+    async (id) => {
+      await client.admin.management.webhooks.test(id);
+    },
+    [client]
+  );
+  (0, import_react6.useEffect)(() => {
+    if (autoFetch) {
+      fetchWebhooks();
+    }
+    if (refetchInterval > 0) {
+      const interval = setInterval(fetchWebhooks, refetchInterval);
+      return () => clearInterval(interval);
+    }
+  }, [autoFetch, refetchInterval, fetchWebhooks]);
+  return {
+    webhooks,
+    isLoading,
+    error,
+    refetch: fetchWebhooks,
+    createWebhook,
+    updateWebhook,
+    deleteWebhook,
+    testWebhook
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  FluxbaseProvider,
+  useAPIKeys,
+  useAdminAuth,
+  useAppSettings,
+  useAuth,
+  useCreateBucket,
+  useDelete,
+  useDeleteBucket,
+  useFluxbaseClient,
+  useFluxbaseQuery,
+  useInsert,
+  useRPC,
+  useRPCBatch,
+  useRPCMutation,
+  useRealtime,
+  useSession,
+  useSignIn,
+  useSignOut,
+  useSignUp,
+  useStorageBuckets,
+  useStorageCopy,
+  useStorageDelete,
+  useStorageDownload,
+  useStorageList,
+  useStorageMove,
+  useStoragePublicUrl,
+  useStorageSignedUrl,
+  useStorageUpload,
+  useSystemSettings,
+  useTable,
+  useTableDeletes,
+  useTableInserts,
+  useTableSubscription,
+  useTableUpdates,
+  useUpdate,
+  useUpdateUser,
+  useUpsert,
+  useUser,
+  useUsers,
+  useWebhooks
+});
+//# sourceMappingURL=index.js.map