@nimbleflux/fluxbase-sdk-react 2026.3.6 → 2026.3.7-rc.2

package/src/use-client-keys.ts

@@ -1,55 +1,63 @@
-import { useState, useEffect, useCallback } from 'react'
-import { useFluxbaseClient } from './context'
-import type { ClientKey, CreateClientKeyRequest } from '@fluxbase/sdk'
+import { useState, useEffect, useCallback } from "react";
+import { useFluxbaseClient } from "./context";
+import type {
+  ClientKey,
+  CreateClientKeyRequest,
+} from "@nimbleflux/fluxbase-sdk";
 
 export interface UseClientKeysOptions {
   /**
    * Whether to automatically fetch client keys on mount
    * @default true
    */
-  autoFetch?: boolean
+  autoFetch?: boolean;
 }
 
 export interface UseClientKeysReturn {
   /**
    * Array of client keys
    */
-  keys: ClientKey[]
+  keys: ClientKey[];
 
   /**
    * Whether keys are being fetched
    */
-  isLoading: boolean
+  isLoading: boolean;
 
   /**
    * Any error that occurred
    */
-  error: Error | null
+  error: Error | null;
 
   /**
    * Refetch client keys
    */
-  refetch: () => Promise<void>
+  refetch: () => Promise<void>;
 
   /**
    * Create a new client key
    */
-  createKey: (request: CreateClientKeyRequest) => Promise<{ key: string; keyData: ClientKey }>
+  createKey: (
+    request: CreateClientKeyRequest,
+  ) => Promise<{ key: string; keyData: ClientKey }>;
 
   /**
    * Update a client key
    */
-  updateKey: (keyId: string, update: { name?: string; description?: string }) => Promise<void>
+  updateKey: (
+    keyId: string,
+    update: { name?: string; description?: string },
+  ) => Promise<void>;
 
   /**
    * Revoke a client key
    */
-  revokeKey: (keyId: string) => Promise<void>
+  revokeKey: (keyId: string) => Promise<void>;
 
   /**
    * Delete a client key
    */
-  deleteKey: (keyId: string) => Promise<void>
+  deleteKey: (keyId: string) => Promise<void>;
 }
 
 /**
@@ -85,81 +93,88 @@ export interface UseClientKeysReturn {
  * }
  * ```
  */
-export function useClientKeys(options: UseClientKeysOptions = {}): UseClientKeysReturn {
-  const { autoFetch = true } = options
-  const client = useFluxbaseClient()
+export function useClientKeys(
+  options: UseClientKeysOptions = {},
+): UseClientKeysReturn {
+  const { autoFetch = true } = options;
+  const client = useFluxbaseClient();
 
-  const [keys, setKeys] = useState<ClientKey[]>([])
-  const [isLoading, setIsLoading] = useState(autoFetch)
-  const [error, setError] = useState<Error | null>(null)
+  const [keys, setKeys] = useState<ClientKey[]>([]);
+  const [isLoading, setIsLoading] = useState(autoFetch);
+  const [error, setError] = useState<Error | null>(null);
 
   /**
    * Fetch client keys from API
    */
   const fetchKeys = useCallback(async () => {
     try {
-      setIsLoading(true)
-      setError(null)
-      const response = await client.admin.management.clientKeys.list()
-      setKeys(response.client_keys)
+      setIsLoading(true);
+      setError(null);
+      const response = await client.admin.management.clientKeys.list();
+      setKeys(response.client_keys);
     } catch (err) {
-      setError(err as Error)
+      setError(err as Error);
     } finally {
-      setIsLoading(false)
+      setIsLoading(false);
     }
-  }, [client])
+  }, [client]);
 
   /**
    * Create a new client key
    */
   const createKey = useCallback(
-    async (request: CreateClientKeyRequest): Promise<{ key: string; keyData: ClientKey }> => {
-      const response = await client.admin.management.clientKeys.create(request)
-      await fetchKeys() // Refresh list
-      return { key: response.key, keyData: response.client_key }
+    async (
+      request: CreateClientKeyRequest,
+    ): Promise<{ key: string; keyData: ClientKey }> => {
+      const response = await client.admin.management.clientKeys.create(request);
+      await fetchKeys(); // Refresh list
+      return { key: response.key, keyData: response.client_key };
     },
-    [client, fetchKeys]
-  )
+    [client, fetchKeys],
+  );
 
   /**
    * Update a client key
    */
   const updateKey = useCallback(
-    async (keyId: string, update: { name?: string; description?: string }): Promise<void> => {
-      await client.admin.management.clientKeys.update(keyId, update)
-      await fetchKeys() // Refresh list
+    async (
+      keyId: string,
+      update: { name?: string; description?: string },
+    ): Promise<void> => {
+      await client.admin.management.clientKeys.update(keyId, update);
+      await fetchKeys(); // Refresh list
     },
-    [client, fetchKeys]
-  )
+    [client, fetchKeys],
+  );
 
   /**
    * Revoke a client key
    */
   const revokeKey = useCallback(
     async (keyId: string): Promise<void> => {
-      await client.admin.management.clientKeys.revoke(keyId)
-      await fetchKeys() // Refresh list
+      await client.admin.management.clientKeys.revoke(keyId);
+      await fetchKeys(); // Refresh list
     },
-    [client, fetchKeys]
-  )
+    [client, fetchKeys],
+  );
 
   /**
    * Delete a client key
    */
   const deleteKey = useCallback(
     async (keyId: string): Promise<void> => {
-      await client.admin.management.clientKeys.delete(keyId)
-      await fetchKeys() // Refresh list
+      await client.admin.management.clientKeys.delete(keyId);
+      await fetchKeys(); // Refresh list
     },
-    [client, fetchKeys]
-  )
+    [client, fetchKeys],
+  );
 
   // Auto-fetch on mount
   useEffect(() => {
     if (autoFetch) {
-      fetchKeys()
+      fetchKeys();
     }
-  }, [autoFetch, fetchKeys])
+  }, [autoFetch, fetchKeys]);
 
   return {
     keys,
@@ -169,17 +184,17 @@ export function useClientKeys(options: UseClientKeysOptions = {}): UseClientKeys
     createKey,
     updateKey,
     revokeKey,
-    deleteKey
-  }
+    deleteKey,
+  };
 }
 
 /**
  * @deprecated Use useClientKeys instead
  */
-export const useAPIKeys = useClientKeys
+export const useAPIKeys = useClientKeys;
 
 /** @deprecated Use UseClientKeysOptions instead */
-export type UseAPIKeysOptions = UseClientKeysOptions
+export type UseAPIKeysOptions = UseClientKeysOptions;
 
 /** @deprecated Use UseClientKeysReturn instead */
-export type UseAPIKeysReturn = UseClientKeysReturn
+export type UseAPIKeysReturn = UseClientKeysReturn;

package/src/use-graphql.ts

@@ -5,7 +5,7 @@
  *
  * @example
  * ```tsx
- * import { useGraphQLQuery, useGraphQLMutation } from '@fluxbase/sdk-react'
+ * import { useGraphQLQuery, useGraphQLMutation } from '@nimbleflux/fluxbase-sdk-react'
  *
  * function UsersList() {
  *   const { data, isLoading, error } = useGraphQLQuery<UsersQuery>(
@@ -33,7 +33,7 @@ import type {
   GraphQLResponse,
   GraphQLError,
   GraphQLRequestOptions,
-} from "@fluxbase/sdk";
+} from "@nimbleflux/fluxbase-sdk";
 
 /**
  * Options for useGraphQLQuery hook
@@ -152,7 +152,7 @@ export interface UseGraphQLMutationOptions<T, V> {
 export function useGraphQLQuery<T = unknown>(
   queryKey: string | readonly unknown[],
   query: string,
-  options?: UseGraphQLQueryOptions<T>
+  options?: UseGraphQLQueryOptions<T>,
 ) {
   const client = useFluxbaseClient();
   const normalizedKey = Array.isArray(queryKey)
@@ -166,7 +166,7 @@ export function useGraphQLQuery<T = unknown>(
         query,
         options?.variables,
         options?.operationName,
-        options?.requestOptions
+        options?.requestOptions,
       );
 
       if (response.errors && response.errors.length > 0) {
@@ -241,7 +241,7 @@ export function useGraphQLMutation<
         mutation,
         variables,
         options?.operationName,
-        options?.requestOptions
+        options?.requestOptions,
       );
 
       if (response.errors && response.errors.length > 0) {
@@ -354,7 +354,7 @@ export function useGraphQL() {
     executeQuery: <T = unknown>(
       query: string,
       variables?: Record<string, unknown>,
-      options?: GraphQLRequestOptions
+      options?: GraphQLRequestOptions,
     ): Promise<GraphQLResponse<T>> => {
       return client.graphql.query<T>(query, variables, options);
     },
@@ -365,7 +365,7 @@ export function useGraphQL() {
     executeMutation: <T = unknown>(
       mutation: string,
       variables?: Record<string, unknown>,
-      options?: GraphQLRequestOptions
+      options?: GraphQLRequestOptions,
     ): Promise<GraphQLResponse<T>> => {
       return client.graphql.mutation<T>(mutation, variables, options);
     },
@@ -377,9 +377,14 @@ export function useGraphQL() {
       document: string,
       variables?: Record<string, unknown>,
       operationName?: string,
-      options?: GraphQLRequestOptions
+      options?: GraphQLRequestOptions,
     ): Promise<GraphQLResponse<T>> => {
-      return client.graphql.execute<T>(document, variables, operationName, options);
+      return client.graphql.execute<T>(
+        document,
+        variables,
+        operationName,
+        options,
+      );
     },
 
     /**

package/src/use-query.ts

@@ -2,15 +2,23 @@
  * Database query hooks for Fluxbase SDK
  */
 
-import { useQuery, useMutation, useQueryClient, type UseQueryOptions } from '@tanstack/react-query'
-import { useFluxbaseClient } from './context'
-import type { QueryBuilder } from '@fluxbase/sdk'
-
-export interface UseFluxbaseQueryOptions<T> extends Omit<UseQueryOptions<T[], Error>, 'queryKey' | 'queryFn'> {
+import {
+  useQuery,
+  useMutation,
+  useQueryClient,
+  type UseQueryOptions,
+} from "@tanstack/react-query";
+import { useFluxbaseClient } from "./context";
+import type { QueryBuilder } from "@nimbleflux/fluxbase-sdk";
+
+export interface UseFluxbaseQueryOptions<T> extends Omit<
+  UseQueryOptions<T[], Error>,
+  "queryKey" | "queryFn"
+> {
   /**
    * Custom query key. If not provided, will use table name and filters.
    */
-  queryKey?: unknown[]
+  queryKey?: unknown[];
 }
 
 /**
@@ -32,35 +40,35 @@ export interface UseFluxbaseQueryOptions<T> extends Omit<UseQueryOptions<T[], Er
  */
 export function useFluxbaseQuery<T = any>(
   buildQuery: (client: ReturnType<typeof useFluxbaseClient>) => QueryBuilder<T>,
-  options?: UseFluxbaseQueryOptions<T>
+  options?: UseFluxbaseQueryOptions<T>,
 ) {
-  const client = useFluxbaseClient()
+  const client = useFluxbaseClient();
 
   // Require queryKey for stable caching - function.toString() is not reliable
   // as it can vary between renders for inline functions
   if (!options?.queryKey) {
     console.warn(
-      '[useFluxbaseQuery] No queryKey provided. This may cause cache misses. ' +
-      'Please provide a stable queryKey in options.'
-    )
+      "[useFluxbaseQuery] No queryKey provided. This may cause cache misses. " +
+        "Please provide a stable queryKey in options.",
+    );
   }
 
-  const queryKey = options?.queryKey || ['fluxbase', 'query', 'unstable']
+  const queryKey = options?.queryKey || ["fluxbase", "query", "unstable"];
 
   return useQuery({
     queryKey,
     queryFn: async () => {
-      const query = buildQuery(client)
-      const { data, error } = await query.execute()
+      const query = buildQuery(client);
+      const { data, error } = await query.execute();
 
       if (error) {
-        throw error
+        throw error;
       }
 
-      return (Array.isArray(data) ? data : data ? [data] : []) as T[]
+      return (Array.isArray(data) ? data : data ? [data] : []) as T[];
     },
     ...options,
-  })
+  });
 }
 
 /**
@@ -87,125 +95,128 @@ export function useFluxbaseQuery<T = any>(
 export function useTable<T = any>(
   table: string,
   buildQuery?: (query: QueryBuilder<T>) => QueryBuilder<T>,
-  options?: UseFluxbaseQueryOptions<T>
+  options?: UseFluxbaseQueryOptions<T>,
 ) {
-  const client = useFluxbaseClient()
-
   // Generate a stable base queryKey from table name
   // When buildQuery is provided without a custom queryKey, warn about potential cache issues
   if (buildQuery && !options?.queryKey) {
     console.warn(
       `[useTable] Using buildQuery without a custom queryKey for table "${table}". ` +
-      'This may cause cache misses. Provide a queryKey that includes your filter values.'
-    )
+        "This may cause cache misses. Provide a queryKey that includes your filter values.",
+    );
   }
 
   return useFluxbaseQuery(
     (client) => {
-      const query = client.from<T>(table)
-      return buildQuery ? buildQuery(query) : query
+      const query = client.from<T>(table);
+      return buildQuery ? buildQuery(query) : query;
     },
     {
       ...options,
       // Use table name as base key, or custom key if provided
-      queryKey: options?.queryKey || ['fluxbase', 'table', table],
-    }
-  )
+      queryKey: options?.queryKey || ["fluxbase", "table", table],
+    },
+  );
 }
 
 /**
  * Hook to insert data into a table
  */
 export function useInsert<T = any>(table: string) {
-  const client = useFluxbaseClient()
-  const queryClient = useQueryClient()
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
 
   return useMutation({
     mutationFn: async (data: Partial<T> | Partial<T>[]) => {
-      const query = client.from<T>(table)
-      const { data: result, error } = await query.insert(data as Partial<T>)
+      const query = client.from<T>(table);
+      const { data: result, error } = await query.insert(data as Partial<T>);
 
       if (error) {
-        throw error
+        throw error;
       }
 
-      return result
+      return result;
     },
     onSuccess: () => {
       // Invalidate all queries for this table
-      queryClient.invalidateQueries({ queryKey: ['fluxbase', 'table', table] })
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
     },
-  })
+  });
 }
 
 /**
  * Hook to update data in a table
  */
 export function useUpdate<T = any>(table: string) {
-  const client = useFluxbaseClient()
-  const queryClient = useQueryClient()
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: async (params: { data: Partial<T>; buildQuery: (query: QueryBuilder<T>) => QueryBuilder<T> }) => {
-      const query = client.from<T>(table)
-      const builtQuery = params.buildQuery(query)
-      const { data: result, error } = await builtQuery.update(params.data)
+    mutationFn: async (params: {
+      data: Partial<T>;
+      buildQuery: (query: QueryBuilder<T>) => QueryBuilder<T>;
+    }) => {
+      const query = client.from<T>(table);
+      const builtQuery = params.buildQuery(query);
+      const { data: result, error } = await builtQuery.update(params.data);
 
       if (error) {
-        throw error
+        throw error;
       }
 
-      return result
+      return result;
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['fluxbase', 'table', table] })
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
     },
-  })
+  });
 }
 
 /**
  * Hook to upsert data into a table
  */
 export function useUpsert<T = any>(table: string) {
-  const client = useFluxbaseClient()
-  const queryClient = useQueryClient()
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
 
   return useMutation({
     mutationFn: async (data: Partial<T> | Partial<T>[]) => {
-      const query = client.from<T>(table)
-      const { data: result, error } = await query.upsert(data as Partial<T>)
+      const query = client.from<T>(table);
+      const { data: result, error } = await query.upsert(data as Partial<T>);
 
       if (error) {
-        throw error
+        throw error;
       }
 
-      return result
+      return result;
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['fluxbase', 'table', table] })
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
     },
-  })
+  });
 }
 
 /**
  * Hook to delete data from a table
  */
 export function useDelete<T = any>(table: string) {
-  const client = useFluxbaseClient()
-  const queryClient = useQueryClient()
+  const client = useFluxbaseClient();
+  const queryClient = useQueryClient();
 
   return useMutation({
-    mutationFn: async (buildQuery: (query: QueryBuilder<T>) => QueryBuilder<T>) => {
-      const query = client.from<T>(table)
-      const builtQuery = buildQuery(query)
-      const { error } = await builtQuery.delete()
+    mutationFn: async (
+      buildQuery: (query: QueryBuilder<T>) => QueryBuilder<T>,
+    ) => {
+      const query = client.from<T>(table);
+      const builtQuery = buildQuery(query);
+      const { error } = await builtQuery.delete();
 
       if (error) {
-        throw error
+        throw error;
       }
     },
     onSuccess: () => {
-      queryClient.invalidateQueries({ queryKey: ['fluxbase', 'table', table] })
+      queryClient.invalidateQueries({ queryKey: ["fluxbase", "table", table] });
     },
-  })
+  });
 }

package/src/use-realtime.ts

@@ -8,7 +8,7 @@ import { useFluxbaseClient } from "./context";
 import type {
   RealtimeCallback,
   RealtimePostgresChangesPayload,
-} from "@fluxbase/sdk";
+} from "@nimbleflux/fluxbase-sdk";
 
 export interface UseRealtimeOptions {
   /**
@@ -98,7 +98,11 @@ export function useRealtime(options: UseRealtimeOptions) {
         // Extract table name from channel (e.g., 'table:public.products' -> 'public.products')
         const tableName = channelName.replace(/^table:/, "");
 
-        const key = invalidateKeyRef.current || ["fluxbase", "table", tableName];
+        const key = invalidateKeyRef.current || [
+          "fluxbase",
+          "table",
+          tableName,
+        ];
         queryClient.invalidateQueries({ queryKey: key });
       }
     };

package/src/use-saml.ts

@@ -4,7 +4,7 @@
 
 import { useMutation, useQuery, useQueryClient } from "@tanstack/react-query";
 import { useFluxbaseClient } from "./context";
-import type { SAMLLoginOptions, SAMLProvider } from "@fluxbase/sdk";
+import type { SAMLLoginOptions, SAMLProvider } from "@nimbleflux/fluxbase-sdk";
 
 /**
  * Hook to get available SAML SSO providers

package/src/use-storage.ts

@@ -16,7 +16,7 @@ import type {
   UploadProgress,
   TransformOptions,
   SignedUrlOptions,
-} from "@fluxbase/sdk";
+} from "@nimbleflux/fluxbase-sdk";
 
 /**
  * Hook to list files in a bucket
@@ -141,7 +141,9 @@ export function useStorageUploadWithProgress(bucket: string) {
         .from(bucket)
         .upload(path, file, {
           ...options,
-          onUploadProgress: (p: import("@fluxbase/sdk").UploadProgress) => {
+          onUploadProgress: (
+            p: import("@nimbleflux/fluxbase-sdk").UploadProgress,
+          ) => {
             setProgress(p);
           },
         });