Add versioning system tables

src/hooks/useEntityVersions.ts

@@ -0,0 +1,199 @@
+import { useState, useEffect } from 'react';
+import { supabase } from '@/integrations/supabase/client';
+import { toast } from 'sonner';
+
+interface EntityVersion {
+  id: string;
+  entity_type: string;
+  entity_id: string;
+  version_number: number;
+  version_data: any;
+  changed_by: string;
+  changed_at: string;
+  change_reason: string | null;
+  change_type: 'created' | 'updated' | 'deleted' | 'restored' | 'archived';
+  submission_id: string | null;
+  is_current: boolean;
+  ip_address_hash: string | null;
+  metadata: any;
+  changer_profile?: {
+    username: string;
+    avatar_url: string | null;
+  };
+}
+
+interface FieldChange {
+  id: string;
+  field_name: string;
+  old_value: any;
+  new_value: any;
+  change_type: 'added' | 'modified' | 'removed';
+  created_at: string;
+}
+
+export function useEntityVersions(entityType: string, entityId: string) {
+  const [versions, setVersions] = useState<EntityVersion[]>([]);
+  const [currentVersion, setCurrentVersion] = useState<EntityVersion | null>(null);
+  const [loading, setLoading] = useState(true);
+  const [fieldHistory, setFieldHistory] = useState<FieldChange[]>([]);
+
+  const fetchVersions = async () => {
+    try {
+      setLoading(true);
+      
+      const { data, error } = await supabase
+        .from('entity_versions')
+        .select('*')
+        .eq('entity_type', entityType)
+        .eq('entity_id', entityId)
+        .order('version_number', { ascending: false });
+
+      if (error) throw error;
+
+      // Fetch profiles separately
+      const userIds = [...new Set(data?.map(v => v.changed_by).filter(Boolean) || [])];
+      const { data: profiles } = await supabase
+        .from('profiles')
+        .select('user_id, username, avatar_url')
+        .in('user_id', userIds);
+
+      const versionsWithProfiles = data?.map(v => ({
+        ...v,
+        changer_profile: profiles?.find(p => p.user_id === v.changed_by)
+      })) as EntityVersion[];
+
+      setVersions(versionsWithProfiles || []);
+      setCurrentVersion(versionsWithProfiles?.find(v => v.is_current) || null);
+    } catch (error: any) {
+      console.error('Error fetching versions:', error);
+      toast.error('Failed to load version history');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const fetchFieldHistory = async (versionId: string) => {
+    try {
+      const { data, error } = await supabase
+        .from('entity_field_history')
+        .select('*')
+        .eq('version_id', versionId)
+        .order('created_at', { ascending: false });
+
+      if (error) throw error;
+
+      setFieldHistory(data as FieldChange[] || []);
+    } catch (error: any) {
+      console.error('Error fetching field history:', error);
+      toast.error('Failed to load field history');
+    }
+  };
+
+  const compareVersions = async (fromVersionId: string, toVersionId: string) => {
+    try {
+      const { data, error } = await supabase.rpc('compare_versions', {
+        p_from_version_id: fromVersionId,
+        p_to_version_id: toVersionId
+      });
+
+      if (error) throw error;
+
+      return data;
+    } catch (error: any) {
+      console.error('Error comparing versions:', error);
+      toast.error('Failed to compare versions');
+      return null;
+    }
+  };
+
+  const rollbackToVersion = async (targetVersionId: string, reason: string) => {
+    try {
+      const { data: userData } = await supabase.auth.getUser();
+      if (!userData.user) throw new Error('Not authenticated');
+
+      const { data, error } = await supabase.rpc('rollback_to_version', {
+        p_entity_type: entityType,
+        p_entity_id: entityId,
+        p_target_version_id: targetVersionId,
+        p_changed_by: userData.user.id,
+        p_reason: reason
+      });
+
+      if (error) throw error;
+
+      toast.success('Successfully rolled back to previous version');
+      await fetchVersions();
+      return data;
+    } catch (error: any) {
+      console.error('Error rolling back version:', error);
+      toast.error('Failed to rollback version');
+      return null;
+    }
+  };
+
+  const createVersion = async (versionData: any, changeReason?: string, submissionId?: string) => {
+    try {
+      const { data: userData } = await supabase.auth.getUser();
+      if (!userData.user) throw new Error('Not authenticated');
+
+      const { data, error } = await supabase.rpc('create_entity_version', {
+        p_entity_type: entityType,
+        p_entity_id: entityId,
+        p_version_data: versionData,
+        p_changed_by: userData.user.id,
+        p_change_reason: changeReason || null,
+        p_submission_id: submissionId || null
+      });
+
+      if (error) throw error;
+
+      await fetchVersions();
+      return data;
+    } catch (error: any) {
+      console.error('Error creating version:', error);
+      toast.error('Failed to create version');
+      return null;
+    }
+  };
+
+  useEffect(() => {
+    if (entityType && entityId) {
+      fetchVersions();
+    }
+  }, [entityType, entityId]);
+
+  // Set up realtime subscription for version changes
+  useEffect(() => {
+    const channel = supabase
+      .channel('entity_versions_changes')
+      .on(
+        'postgres_changes',
+        {
+          event: '*',
+          schema: 'public',
+          table: 'entity_versions',
+          filter: `entity_type=eq.${entityType},entity_id=eq.${entityId}`
+        },
+        () => {
+          fetchVersions();
+        }
+      )
+      .subscribe();
+
+    return () => {
+      supabase.removeChannel(channel);
+    };
+  }, [entityType, entityId]);
+
+  return {
+    versions,
+    currentVersion,
+    loading,
+    fieldHistory,
+    fetchVersions,
+    fetchFieldHistory,
+    compareVersions,
+    rollbackToVersion,
+    createVersion
+  };
+}