@jmruthers/pace-core 0.5.54 → 0.5.55

package/src/hooks/useFileReference.ts

@@ -0,0 +1,232 @@
+// File Reference React Hooks
+// Provides React hooks for managing file references
+
+import { useState, useCallback } from 'react';
+import { SupabaseClient } from '@supabase/supabase-js';
+import { 
+  FileReference, 
+  FileUploadOptions, 
+  FileReferenceService,
+  FileUploadResult 
+} from '../types/file-reference';
+import { createFileReferenceService, uploadFileWithReference } from '../utils/file-reference';
+
+export function useFileReference(supabase: SupabaseClient) {
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const service = createFileReferenceService(supabase);
+
+  const uploadFile = useCallback(async (options: FileUploadOptions, file: File): Promise<FileUploadResult | null> => {
+    setIsLoading(true);
+    setError(null);
+    
+    try {
+      const result = await uploadFileWithReference(supabase, options, file);
+      return result;
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Upload failed';
+      setError(errorMessage);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [supabase]);
+
+  const getFileReference = useCallback(async (table_name: string, record_id: string, organisation_id: string): Promise<FileReference | null> => {
+    setIsLoading(true);
+    setError(null);
+    
+    try {
+      return await service.getFileReference(table_name, record_id, organisation_id);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Failed to get file reference';
+      setError(errorMessage);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [service]);
+
+  const getFileUrl = useCallback(async (table_name: string, record_id: string, organisation_id: string): Promise<string | null> => {
+    setIsLoading(true);
+    setError(null);
+    
+    try {
+      return await service.getFileUrl(table_name, record_id, organisation_id);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Failed to get file URL';
+      setError(errorMessage);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [service]);
+
+  const getSignedUrl = useCallback(async (table_name: string, record_id: string, organisation_id: string, expires_in?: number): Promise<string | null> => {
+    setIsLoading(true);
+    setError(null);
+    
+    try {
+      return await service.getSignedUrl(table_name, record_id, organisation_id, expires_in);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Failed to get signed URL';
+      setError(errorMessage);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [service]);
+
+  const updateFileReference = useCallback(async (id: string, updates: Partial<FileReference>): Promise<FileReference | null> => {
+    setIsLoading(true);
+    setError(null);
+    
+    try {
+      return await service.updateFileReference(id, updates);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Failed to update file reference';
+      setError(errorMessage);
+      return null;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [service]);
+
+  const deleteFileReference = useCallback(async (table_name: string, record_id: string, organisation_id: string, delete_file?: boolean): Promise<boolean> => {
+    setIsLoading(true);
+    setError(null);
+    
+    try {
+      return await service.deleteFileReference(table_name, record_id, organisation_id, delete_file);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Failed to delete file reference';
+      setError(errorMessage);
+      return false;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [service]);
+
+  const listFileReferences = useCallback(async (table_name: string, record_id: string, organisation_id: string): Promise<FileReference[]> => {
+    setIsLoading(true);
+    setError(null);
+    
+    try {
+      return await service.listFileReferences(table_name, record_id, organisation_id);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Failed to list file references';
+      setError(errorMessage);
+      return [];
+    } finally {
+      setIsLoading(false);
+    }
+  }, [service]);
+
+  const getFileCount = useCallback(async (table_name: string, record_id: string, organisation_id: string): Promise<number> => {
+    setIsLoading(true);
+    setError(null);
+    
+    try {
+      return await service.getFileCount(table_name, record_id, organisation_id);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'Failed to get file count';
+      setError(errorMessage);
+      return 0;
+    } finally {
+      setIsLoading(false);
+    }
+  }, [service]);
+
+  const clearError = useCallback(() => {
+    setError(null);
+  }, []);
+
+  return {
+    isLoading,
+    error,
+    uploadFile,
+    getFileReference,
+    getFileUrl,
+    getSignedUrl,
+    updateFileReference,
+    deleteFileReference,
+    listFileReferences,
+    getFileCount,
+    clearError
+  };
+}
+
+export function useFileReferenceForRecord(
+  supabase: SupabaseClient,
+  table_name: string,
+  record_id: string,
+  organisation_id: string
+) {
+  const {
+    isLoading,
+    error,
+    getFileUrl,
+    getFileReference,
+    updateFileReference,
+    deleteFileReference,
+    listFileReferences,
+    getFileCount,
+    clearError
+  } = useFileReference(supabase);
+
+  const [fileUrl, setFileUrl] = useState<string | null>(null);
+  const [fileReference, setFileReference] = useState<FileReference | null>(null);
+  const [fileReferences, setFileReferences] = useState<FileReference[]>([]);
+  const [fileCount, setFileCount] = useState<number>(0);
+
+  const loadFileReference = useCallback(async () => {
+    const reference = await getFileReference(table_name, record_id, organisation_id);
+    setFileReference(reference);
+    return reference;
+  }, [getFileReference, table_name, record_id, organisation_id]);
+
+  const loadFileUrl = useCallback(async () => {
+    const url = await getFileUrl(table_name, record_id, organisation_id);
+    setFileUrl(url);
+    return url;
+  }, [getFileUrl, table_name, record_id, organisation_id]);
+
+  const loadFileReferences = useCallback(async () => {
+    const references = await listFileReferences(table_name, record_id, organisation_id);
+    setFileReferences(references);
+    return references;
+  }, [listFileReferences, table_name, record_id, organisation_id]);
+
+  const loadFileCount = useCallback(async () => {
+    const count = await getFileCount(table_name, record_id, organisation_id);
+    setFileCount(count);
+    return count;
+  }, [getFileCount, table_name, record_id, organisation_id]);
+
+  const deleteFile = useCallback(async (delete_file?: boolean) => {
+    const success = await deleteFileReference(table_name, record_id, organisation_id, delete_file);
+    if (success) {
+      setFileReference(null);
+      setFileUrl(null);
+      await loadFileCount();
+    }
+    return success;
+  }, [deleteFileReference, table_name, record_id, organisation_id, loadFileCount]);
+
+  return {
+    isLoading,
+    error,
+    fileUrl,
+    fileReference,
+    fileReferences,
+    fileCount,
+    loadFileReference,
+    loadFileUrl,
+    loadFileReferences,
+    loadFileCount,
+    deleteFile,
+    updateFileReference,
+    clearError
+  };
+}