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

package/src/use-table-export.ts

@@ -4,8 +4,8 @@
  * React hooks for exporting database tables to knowledge bases and managing sync configurations.
  */
 
-import { useState, useEffect, useCallback } from 'react'
-import { useFluxbaseClient } from './context'
+import { useState, useEffect, useCallback } from "react";
+import { useFluxbaseClient } from "./context";
 import type {
   ExportTableOptions,
   ExportTableResult,
@@ -13,23 +13,23 @@ import type {
   TableExportSyncConfig,
   CreateTableExportSyncConfig,
   UpdateTableExportSyncConfig,
-} from '@fluxbase/sdk'
+} from "@nimbleflux/fluxbase-sdk";
 
 // ============================================================================
 // useTableDetails Hook
 // ============================================================================
 
 export interface UseTableDetailsOptions {
-  schema?: string
-  table?: string
-  autoFetch?: boolean
+  schema?: string;
+  table?: string;
+  autoFetch?: boolean;
 }
 
 export interface UseTableDetailsReturn {
-  data: TableDetails | null
-  isLoading: boolean
-  error: Error | null
-  refetch: () => Promise<void>
+  data: TableDetails | null;
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => Promise<void>;
 }
 
 /**
@@ -56,44 +56,46 @@ export interface UseTableDetailsReturn {
  * }
  * ```
  */
-export function useTableDetails(options: UseTableDetailsOptions): UseTableDetailsReturn {
-  const { schema, table, autoFetch = true } = options
-  const client = useFluxbaseClient()
+export function useTableDetails(
+  options: UseTableDetailsOptions,
+): UseTableDetailsReturn {
+  const { schema, table, autoFetch = true } = options;
+  const client = useFluxbaseClient();
 
-  const [data, setData] = useState<TableDetails | null>(null)
-  const [isLoading, setIsLoading] = useState(autoFetch && !!schema && !!table)
-  const [error, setError] = useState<Error | null>(null)
+  const [data, setData] = useState<TableDetails | null>(null);
+  const [isLoading, setIsLoading] = useState(autoFetch && !!schema && !!table);
+  const [error, setError] = useState<Error | null>(null);
 
   const fetchData = useCallback(async () => {
-    if (!schema || !table) return
+    if (!schema || !table) return;
 
     try {
-      setIsLoading(true)
-      setError(null)
-      const result = await client.admin.ai.getTableDetails(schema, table)
+      setIsLoading(true);
+      setError(null);
+      const result = await client.admin.ai.getTableDetails(schema, table);
       if (result.error) {
-        throw result.error
+        throw result.error;
       }
-      setData(result.data)
+      setData(result.data);
     } catch (err) {
-      setError(err as Error)
+      setError(err as Error);
     } finally {
-      setIsLoading(false)
+      setIsLoading(false);
     }
-  }, [client, schema, table])
+  }, [client, schema, table]);
 
   useEffect(() => {
     if (autoFetch && schema && table) {
-      fetchData()
+      fetchData();
     }
-  }, [autoFetch, fetchData, schema, table])
+  }, [autoFetch, fetchData, schema, table]);
 
   return {
     data,
     isLoading,
     error,
     refetch: fetchData,
-  }
+  };
 }
 
 // ============================================================================
@@ -101,10 +103,12 @@ export function useTableDetails(options: UseTableDetailsOptions): UseTableDetail
 // ============================================================================
 
 export interface UseExportTableReturn {
-  exportTable: (options: ExportTableOptions) => Promise<ExportTableResult | null>
-  isLoading: boolean
-  error: Error | null
-  reset: () => void
+  exportTable: (
+    options: ExportTableOptions,
+  ) => Promise<ExportTableResult | null>;
+  isLoading: boolean;
+  error: Error | null;
+  reset: () => void;
 }
 
 /**
@@ -136,42 +140,45 @@ export interface UseExportTableReturn {
  * ```
  */
 export function useExportTable(knowledgeBaseId: string): UseExportTableReturn {
-  const client = useFluxbaseClient()
+  const client = useFluxbaseClient();
 
-  const [isLoading, setIsLoading] = useState(false)
-  const [error, setError] = useState<Error | null>(null)
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
 
   const exportTable = useCallback(
     async (options: ExportTableOptions): Promise<ExportTableResult | null> => {
       try {
-        setIsLoading(true)
-        setError(null)
-        const result = await client.admin.ai.exportTable(knowledgeBaseId, options)
+        setIsLoading(true);
+        setError(null);
+        const result = await client.admin.ai.exportTable(
+          knowledgeBaseId,
+          options,
+        );
         if (result.error) {
-          throw result.error
+          throw result.error;
         }
-        return result.data
+        return result.data;
       } catch (err) {
-        setError(err as Error)
-        return null
+        setError(err as Error);
+        return null;
       } finally {
-        setIsLoading(false)
+        setIsLoading(false);
       }
     },
     [client, knowledgeBaseId],
-  )
+  );
 
   const reset = useCallback(() => {
-    setError(null)
-    setIsLoading(false)
-  }, [])
+    setError(null);
+    setIsLoading(false);
+  }, []);
 
   return {
     exportTable,
     isLoading,
     error,
     reset,
-  }
+  };
 }
 
 // ============================================================================
@@ -179,14 +186,14 @@ export function useExportTable(knowledgeBaseId: string): UseExportTableReturn {
 // ============================================================================
 
 export interface UseTableExportSyncsOptions {
-  autoFetch?: boolean
+  autoFetch?: boolean;
 }
 
 export interface UseTableExportSyncsReturn {
-  configs: TableExportSyncConfig[]
-  isLoading: boolean
-  error: Error | null
-  refetch: () => Promise<void>
+  configs: TableExportSyncConfig[];
+  isLoading: boolean;
+  error: Error | null;
+  refetch: () => Promise<void>;
 }
 
 /**
@@ -215,41 +222,42 @@ export function useTableExportSyncs(
   knowledgeBaseId: string,
   options: UseTableExportSyncsOptions = {},
 ): UseTableExportSyncsReturn {
-  const { autoFetch = true } = options
-  const client = useFluxbaseClient()
+  const { autoFetch = true } = options;
+  const client = useFluxbaseClient();
 
-  const [configs, setConfigs] = useState<TableExportSyncConfig[]>([])
-  const [isLoading, setIsLoading] = useState(autoFetch)
-  const [error, setError] = useState<Error | null>(null)
+  const [configs, setConfigs] = useState<TableExportSyncConfig[]>([]);
+  const [isLoading, setIsLoading] = useState(autoFetch);
+  const [error, setError] = useState<Error | null>(null);
 
   const fetchData = useCallback(async () => {
     try {
-      setIsLoading(true)
-      setError(null)
-      const result = await client.admin.ai.listTableExportSyncs(knowledgeBaseId)
+      setIsLoading(true);
+      setError(null);
+      const result =
+        await client.admin.ai.listTableExportSyncs(knowledgeBaseId);
       if (result.error) {
-        throw result.error
+        throw result.error;
       }
-      setConfigs(result.data || [])
+      setConfigs(result.data || []);
     } catch (err) {
-      setError(err as Error)
+      setError(err as Error);
     } finally {
-      setIsLoading(false)
+      setIsLoading(false);
     }
-  }, [client, knowledgeBaseId])
+  }, [client, knowledgeBaseId]);
 
   useEffect(() => {
     if (autoFetch) {
-      fetchData()
+      fetchData();
     }
-  }, [autoFetch, fetchData])
+  }, [autoFetch, fetchData]);
 
   return {
     configs,
     isLoading,
     error,
     refetch: fetchData,
-  }
+  };
 }
 
 // ============================================================================
@@ -257,9 +265,11 @@ export function useTableExportSyncs(
 // ============================================================================
 
 export interface UseCreateTableExportSyncReturn {
-  createSync: (config: CreateTableExportSyncConfig) => Promise<TableExportSyncConfig | null>
-  isLoading: boolean
-  error: Error | null
+  createSync: (
+    config: CreateTableExportSyncConfig,
+  ) => Promise<TableExportSyncConfig | null>;
+  isLoading: boolean;
+  error: Error | null;
 }
 
 /**
@@ -289,37 +299,44 @@ export interface UseCreateTableExportSyncReturn {
  * }
  * ```
  */
-export function useCreateTableExportSync(knowledgeBaseId: string): UseCreateTableExportSyncReturn {
-  const client = useFluxbaseClient()
+export function useCreateTableExportSync(
+  knowledgeBaseId: string,
+): UseCreateTableExportSyncReturn {
+  const client = useFluxbaseClient();
 
-  const [isLoading, setIsLoading] = useState(false)
-  const [error, setError] = useState<Error | null>(null)
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
 
   const createSync = useCallback(
-    async (config: CreateTableExportSyncConfig): Promise<TableExportSyncConfig | null> => {
+    async (
+      config: CreateTableExportSyncConfig,
+    ): Promise<TableExportSyncConfig | null> => {
       try {
-        setIsLoading(true)
-        setError(null)
-        const result = await client.admin.ai.createTableExportSync(knowledgeBaseId, config)
+        setIsLoading(true);
+        setError(null);
+        const result = await client.admin.ai.createTableExportSync(
+          knowledgeBaseId,
+          config,
+        );
         if (result.error) {
-          throw result.error
+          throw result.error;
         }
-        return result.data
+        return result.data;
       } catch (err) {
-        setError(err as Error)
-        return null
+        setError(err as Error);
+        return null;
       } finally {
-        setIsLoading(false)
+        setIsLoading(false);
       }
     },
     [client, knowledgeBaseId],
-  )
+  );
 
   return {
     createSync,
     isLoading,
     error,
-  }
+  };
 }
 
 // ============================================================================
@@ -327,45 +344,57 @@ export function useCreateTableExportSync(knowledgeBaseId: string): UseCreateTabl
 // ============================================================================
 
 export interface UseUpdateTableExportSyncReturn {
-  updateSync: (syncId: string, updates: UpdateTableExportSyncConfig) => Promise<TableExportSyncConfig | null>
-  isLoading: boolean
-  error: Error | null
+  updateSync: (
+    syncId: string,
+    updates: UpdateTableExportSyncConfig,
+  ) => Promise<TableExportSyncConfig | null>;
+  isLoading: boolean;
+  error: Error | null;
 }
 
 /**
  * Hook for updating a table export sync configuration
  */
-export function useUpdateTableExportSync(knowledgeBaseId: string): UseUpdateTableExportSyncReturn {
-  const client = useFluxbaseClient()
+export function useUpdateTableExportSync(
+  knowledgeBaseId: string,
+): UseUpdateTableExportSyncReturn {
+  const client = useFluxbaseClient();
 
-  const [isLoading, setIsLoading] = useState(false)
-  const [error, setError] = useState<Error | null>(null)
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
 
   const updateSync = useCallback(
-    async (syncId: string, updates: UpdateTableExportSyncConfig): Promise<TableExportSyncConfig | null> => {
+    async (
+      syncId: string,
+      updates: UpdateTableExportSyncConfig,
+    ): Promise<TableExportSyncConfig | null> => {
       try {
-        setIsLoading(true)
-        setError(null)
-        const result = await client.admin.ai.updateTableExportSync(knowledgeBaseId, syncId, updates)
+        setIsLoading(true);
+        setError(null);
+        const result = await client.admin.ai.updateTableExportSync(
+          knowledgeBaseId,
+          syncId,
+          updates,
+        );
         if (result.error) {
-          throw result.error
+          throw result.error;
         }
-        return result.data
+        return result.data;
       } catch (err) {
-        setError(err as Error)
-        return null
+        setError(err as Error);
+        return null;
       } finally {
-        setIsLoading(false)
+        setIsLoading(false);
       }
     },
     [client, knowledgeBaseId],
-  )
+  );
 
   return {
     updateSync,
     isLoading,
     error,
-  }
+  };
 }
 
 // ============================================================================
@@ -373,45 +402,50 @@ export function useUpdateTableExportSync(knowledgeBaseId: string): UseUpdateTabl
 // ============================================================================
 
 export interface UseDeleteTableExportSyncReturn {
-  deleteSync: (syncId: string) => Promise<boolean>
-  isLoading: boolean
-  error: Error | null
+  deleteSync: (syncId: string) => Promise<boolean>;
+  isLoading: boolean;
+  error: Error | null;
 }
 
 /**
  * Hook for deleting a table export sync configuration
  */
-export function useDeleteTableExportSync(knowledgeBaseId: string): UseDeleteTableExportSyncReturn {
-  const client = useFluxbaseClient()
+export function useDeleteTableExportSync(
+  knowledgeBaseId: string,
+): UseDeleteTableExportSyncReturn {
+  const client = useFluxbaseClient();
 
-  const [isLoading, setIsLoading] = useState(false)
-  const [error, setError] = useState<Error | null>(null)
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
 
   const deleteSync = useCallback(
     async (syncId: string): Promise<boolean> => {
       try {
-        setIsLoading(true)
-        setError(null)
-        const result = await client.admin.ai.deleteTableExportSync(knowledgeBaseId, syncId)
+        setIsLoading(true);
+        setError(null);
+        const result = await client.admin.ai.deleteTableExportSync(
+          knowledgeBaseId,
+          syncId,
+        );
         if (result.error) {
-          throw result.error
+          throw result.error;
         }
-        return true
+        return true;
       } catch (err) {
-        setError(err as Error)
-        return false
+        setError(err as Error);
+        return false;
       } finally {
-        setIsLoading(false)
+        setIsLoading(false);
       }
     },
     [client, knowledgeBaseId],
-  )
+  );
 
   return {
     deleteSync,
     isLoading,
     error,
-  }
+  };
 }
 
 // ============================================================================
@@ -419,9 +453,9 @@ export function useDeleteTableExportSync(knowledgeBaseId: string): UseDeleteTabl
 // ============================================================================
 
 export interface UseTriggerTableExportSyncReturn {
-  triggerSync: (syncId: string) => Promise<ExportTableResult | null>
-  isLoading: boolean
-  error: Error | null
+  triggerSync: (syncId: string) => Promise<ExportTableResult | null>;
+  isLoading: boolean;
+  error: Error | null;
 }
 
 /**
@@ -447,35 +481,40 @@ export interface UseTriggerTableExportSyncReturn {
  * }
  * ```
  */
-export function useTriggerTableExportSync(knowledgeBaseId: string): UseTriggerTableExportSyncReturn {
-  const client = useFluxbaseClient()
+export function useTriggerTableExportSync(
+  knowledgeBaseId: string,
+): UseTriggerTableExportSyncReturn {
+  const client = useFluxbaseClient();
 
-  const [isLoading, setIsLoading] = useState(false)
-  const [error, setError] = useState<Error | null>(null)
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<Error | null>(null);
 
   const triggerSync = useCallback(
     async (syncId: string): Promise<ExportTableResult | null> => {
       try {
-        setIsLoading(true)
-        setError(null)
-        const result = await client.admin.ai.triggerTableExportSync(knowledgeBaseId, syncId)
+        setIsLoading(true);
+        setError(null);
+        const result = await client.admin.ai.triggerTableExportSync(
+          knowledgeBaseId,
+          syncId,
+        );
         if (result.error) {
-          throw result.error
+          throw result.error;
         }
-        return result.data
+        return result.data;
       } catch (err) {
-        setError(err as Error)
-        return null
+        setError(err as Error);
+        return null;
       } finally {
-        setIsLoading(false)
+        setIsLoading(false);
       }
     },
     [client, knowledgeBaseId],
-  )
+  );
 
   return {
     triggerSync,
     isLoading,
     error,
-  }
+  };
 }