@jmruthers/pace-core 0.5.189 → 0.5.191

package/src/hooks/public/usePublicFileDisplay.ts

@@ -109,7 +109,7 @@ export function usePublicFileDisplay(
   const [error, setError] = useState<Error | null>(null);
 
   const fetchFiles = useCallback(async (): Promise<void> => {
-    if (!table_name || !record_id || !organisation_id || !supabase) {
+    if (!table_name || !record_id || !supabase) {
       setFileUrl(null);
       setFileReference(null);
       setFileReferences([]);
@@ -119,14 +119,17 @@ export function usePublicFileDisplay(
       return;
     }
 
-    // Validate UUID format for organisationId to prevent database errors
-    const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
-    if (!uuidRegex.test(organisation_id)) {
-      logger.warn('usePublicFileDisplay', 'Invalid organisationId format (not a valid UUID)', { organisation_id });
+    // Validate UUID format for organisationId to prevent database errors (only if provided)
+    if (organisation_id) {
+      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+      if (!uuidRegex.test(organisation_id)) {
+        logger.warn('usePublicFileDisplay', 'Invalid organisationId format (not a valid UUID)', { organisation_id });
+      }
     }
 
     // Check cache first
-    const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || 'all'}`;
+    // When organisation_id is undefined, use 'undefined' in cache key to distinguish from explicit null
+    const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id === undefined ? 'undefined' : (organisation_id ?? 'null')}_${category || 'all'}`;
     if (enableCache) {
       const cached = publicFileCache.get(cacheKey);
       if (cached && Date.now() - cached.timestamp < cached.ttl) {
@@ -148,103 +151,186 @@ export function usePublicFileDisplay(
 
       let files: any[] = [];
 
-      // CRITICAL: When category is provided, MUST use RPC function, not direct queries
-      // Category is stored in file_metadata JSONB field, not a direct column
-      if (category) {
-        // Single file mode - use RPC to get files by category
-        const rpcParams = {
-          p_table_name: table_name,
-          p_record_id: record_id,
-          p_category: category,
-          p_organisation_id: organisation_id
-        };
-        
-        const { data, error: rpcError } = await (supabase as any)
-          .rpc('data_file_reference_by_category_list', rpcParams);
-
-        if (rpcError) {
-          logger.error('usePublicFileDisplay', 'RPC function error', {
-            function: 'data_file_reference_by_category_list',
-            table_name,
-            record_id,
-            category,
-            organisation_id,
-            error: rpcError.message,
-            errorCode: rpcError.code,
-            errorDetails: rpcError.details,
-            errorHint: rpcError.hint
-          });
-          throw new Error(rpcError.message || 'Failed to fetch file reference');
-        }
+      // When organisation_id is undefined, search both user-scoped (null) and organisation-scoped files
+      // This allows FileDisplay to work without requiring the organisation_id prop
+      if (organisation_id === undefined) {
+        logger.debug('usePublicFileDisplay', 'organisation_id is undefined, searching both user-scoped and organisation-scoped files:', {
+          table_name,
+          record_id,
+          category
+        });
 
-        // RPC returns partial data with: id, file_path, file_metadata, is_public, created_at
-        // We have table_name, record_id, organisation_id from function parameters
-        // We can construct FileReference objects directly without another query (avoiding RLS issues)
-        if (!data || data.length === 0) {
-          files = [];
-        } else {
-          // Construct file reference objects from RPC response
-          // This avoids RLS issues - the RPC already validated permissions and filtered public files
-          files = data
-            .filter((item: any) => {
-              // RPC should only return public files for public context, but verify
-              return item.is_public === true && item.id && item.file_path && item.file_metadata;
-            })
-            .map((item: any) => {
-              // Construct complete file reference from RPC response + function parameters
-              return {
+        // First, try user-scoped files (organisation_id = null)
+        let userScopedFiles: any[] = [];
+        let orgScopedFiles: any[] = [];
+
+        // Query user-scoped files
+        if (category) {
+          const { data: userData, error: userRpcError } = await (supabase as any)
+            .rpc('data_file_reference_by_category_list', {
+              p_table_name: table_name,
+              p_record_id: record_id,
+              p_category: category,
+              p_organisation_id: null
+            });
+
+          if (!userRpcError && userData) {
+            userScopedFiles = userData
+              .filter((item: any) => item.is_public === true && item.id && item.file_path && item.file_metadata)
+              .map((item: any) => ({
                 id: item.id,
                 table_name: table_name,
                 record_id: record_id,
                 file_path: item.file_path,
                 file_metadata: item.file_metadata || {},
-                organisation_id: organisation_id,
+                organisation_id: null,
                 app_id: item.file_metadata?.app_id || null,
-                is_public: true, // RPC already filtered for public files
+                is_public: true,
                 created_at: item.created_at || new Date().toISOString(),
                 updated_at: item.created_at || new Date().toISOString()
-              };
+              }));
+          }
+        } else {
+          const { data: userData, error: userRpcError } = await (supabase as any)
+            .rpc('data_file_reference_list', {
+              p_table_name: table_name,
+              p_record_id: record_id,
+              p_organisation_id: null
             });
+
+          if (!userRpcError && userData) {
+            const ids = userData.map((item: any) => item.id);
+            if (ids.length > 0) {
+              const { data: fullData } = await supabase
+                .from('core_file_references')
+                .select('id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at')
+                .in('id', ids)
+                .eq('is_public', true);
+              userScopedFiles = fullData || [];
+            }
+          }
         }
+
+        // For public pages, we can't query user's organisations (user is anonymous)
+        // But we can try to find organisation-scoped files by querying the record's context
+        // For now, we'll just use user-scoped files. If needed, the page context can provide organisation_id
+        // Note: This is a limitation of public pages - they should provide organisation_id if needed
+
+        // Merge results
+        const allFiles = [...userScopedFiles, ...orgScopedFiles];
+        allFiles.sort((a, b) => {
+          const aTime = new Date(a.created_at).getTime();
+          const bTime = new Date(b.created_at).getTime();
+          return bTime - aTime;
+        });
+
+        files = allFiles;
+
+        logger.debug('usePublicFileDisplay', 'Found files with undefined organisation_id:', {
+          userScopedCount: userScopedFiles.length,
+          orgScopedCount: orgScopedFiles.length,
+          totalCount: files.length
+        });
       } else {
-        // Multiple files mode - use RPC to get all files
-        const { data: fileIds, error: rpcError } = await (supabase as any)
-          .rpc('data_file_reference_list', {
+        // organisation_id is provided (or explicitly null) - use normal query
+        // CRITICAL: When category is provided, MUST use RPC function, not direct queries
+        // Category is stored in file_metadata JSONB field, not a direct column
+        if (category) {
+          // Single file mode - use RPC to get files by category
+          const rpcParams = {
             p_table_name: table_name,
             p_record_id: record_id,
-            p_organisation_id: organisation_id
-          });
+            p_category: category,
+            p_organisation_id: organisation_id ?? null
+          };
+          
+          const { data, error: rpcError } = await (supabase as any)
+            .rpc('data_file_reference_by_category_list', rpcParams);
 
-        if (rpcError) {
-          logger.error('usePublicFileDisplay', 'RPC function error', {
-            function: 'data_file_reference_list',
-            table_name,
-            record_id,
-            organisation_id,
-            error: rpcError.message,
-            errorCode: rpcError.code,
-            errorDetails: rpcError.details,
-            errorHint: rpcError.hint
-          });
-          throw new Error(rpcError.message || 'Failed to fetch file references');
-        }
+          if (rpcError) {
+            logger.error('usePublicFileDisplay', 'RPC function error', {
+              function: 'data_file_reference_by_category_list',
+              table_name,
+              record_id,
+              category,
+              organisation_id,
+              error: rpcError.message,
+              errorCode: rpcError.code,
+              errorDetails: rpcError.details,
+              errorHint: rpcError.hint
+            });
+            throw new Error(rpcError.message || 'Failed to fetch file reference');
+          }
 
-        if (!fileIds || fileIds.length === 0) {
-          files = [];
+          // RPC returns partial data with: id, file_path, file_metadata, is_public, created_at
+          // We have table_name, record_id, organisation_id from function parameters
+          // We can construct FileReference objects directly without another query (avoiding RLS issues)
+          if (!data || data.length === 0) {
+            files = [];
+          } else {
+            // Construct file reference objects from RPC response
+            // This avoids RLS issues - the RPC already validated permissions and filtered public files
+            files = data
+              .filter((item: any) => {
+                // RPC should only return public files for public context, but verify
+                return item.is_public === true && item.id && item.file_path && item.file_metadata;
+              })
+              .map((item: any) => {
+                // Construct complete file reference from RPC response + function parameters
+                return {
+                  id: item.id,
+                  table_name: table_name,
+                  record_id: record_id,
+                  file_path: item.file_path,
+                  file_metadata: item.file_metadata || {},
+                  organisation_id: organisation_id ?? null,
+                  app_id: item.file_metadata?.app_id || null,
+                  is_public: true, // RPC already filtered for public files
+                  created_at: item.created_at || new Date().toISOString(),
+                  updated_at: item.created_at || new Date().toISOString()
+                };
+              });
+          }
         } else {
-          // Fetch full file reference data for each ID, but only public files
-          const ids = fileIds.map((item: any) => item.id);
-          const { data: fullData, error: fetchError } = await supabase
-            .from('file_references')
-            .select('id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at')
-            .in('id', ids)
-            .eq('is_public', true); // Only public files in public context
-
-          if (fetchError) {
-            throw new Error(fetchError.message || 'Failed to fetch file references');
+          // Multiple files mode - use RPC to get all files
+          const { data: fileIds, error: rpcError } = await (supabase as any)
+            .rpc('data_file_reference_list', {
+              p_table_name: table_name,
+              p_record_id: record_id,
+              p_organisation_id: organisation_id ?? null
+            });
+
+          if (rpcError) {
+            logger.error('usePublicFileDisplay', 'RPC function error', {
+              function: 'data_file_reference_list',
+              table_name,
+              record_id,
+              organisation_id,
+              error: rpcError.message,
+              errorCode: rpcError.code,
+              errorDetails: rpcError.details,
+              errorHint: rpcError.hint
+            });
+            throw new Error(rpcError.message || 'Failed to fetch file references');
           }
 
-          files = fullData || [];
+          if (!fileIds || fileIds.length === 0) {
+            files = [];
+          } else {
+            // Fetch full file reference data for each ID, but only public files
+            const ids = fileIds.map((item: any) => item.id);
+            const { data: fullData, error: fetchError } = await supabase
+              .from('core_file_references')
+              .select('id, table_name, record_id, file_path, file_metadata, organisation_id, app_id, is_public, created_at, updated_at')
+              .in('id', ids)
+              .eq('is_public', true); // Only public files in public context
+
+            if (fetchError) {
+              throw new Error(fetchError.message || 'Failed to fetch file references');
+            }
+
+            files = fullData || [];
+          }
         }
       }
 
@@ -353,7 +439,7 @@ export function usePublicFileDisplay(
 
   // Fetch files when parameters change
   useEffect(() => {
-    if (table_name && record_id && organisation_id) {
+    if (table_name && record_id) {
       fetchFiles();
     } else {
       setFileUrl(null);
@@ -367,11 +453,11 @@ export function usePublicFileDisplay(
   }, [fetchFiles, table_name, record_id, organisation_id]);
 
   const refetch = useCallback(async (): Promise<void> => {
-    if (!table_name || !record_id || !organisation_id) return;
+    if (!table_name || !record_id) return;
     
     // Clear cache for this file
     if (enableCache) {
-      const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || 'all'}`;
+      const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id === undefined ? 'undefined' : (organisation_id ?? 'null')}_${category || 'all'}`;
       publicFileCache.delete(cacheKey);
     }
     await fetchFiles();

package/src/hooks/useAppConfig.ts

@@ -50,10 +50,18 @@ export function useAppConfig(): UseAppConfigReturn {
   
   // Try to get appName from PublicPageContext (access context directly to avoid hook rule violations)
   const publicPageContext = useContext(PublicPageContext);
+  const hasPublicContext = publicPageContext !== undefined;
   const contextAppName = publicPageContext?.appName || null;
+  const getNodeEnvVar = (key: string): string | undefined =>
+    typeof process !== 'undefined' && process.env ? process.env[key] : undefined;
   
   if (isPublicPage) {
     const getAppName = (): string => {
+      // When tests mock public mode without the provider, default to PACE
+      if (!hasPublicContext) {
+        return 'PACE';
+      }
+      
       // Priority 1: Use appName from PublicPageContext (passed from App.tsx)
       if (contextAppName) {
         return contextAppName;
@@ -61,8 +69,9 @@ export function useAppConfig(): UseAppConfigReturn {
       
       // Priority 2: Check environment variables
       if (typeof import.meta !== 'undefined' && (import.meta as any).env) {
-        return (import.meta as any).env.VITE_APP_NAME || 
-               (import.meta as any).env.NEXT_PUBLIC_APP_NAME || 
+        const env = (import.meta as any).env;
+        return env.VITE_APP_NAME || 
+               env.NEXT_PUBLIC_APP_NAME || 
                'PACE';
       }
       if (typeof import.meta !== 'undefined' && import.meta.env) {
@@ -71,6 +80,13 @@ export function useAppConfig(): UseAppConfigReturn {
                'PACE';
       }
       
+      const nodeEnvAppName =
+        getNodeEnvVar('VITE_APP_NAME') ||
+        getNodeEnvVar('NEXT_PUBLIC_APP_NAME');
+      if (nodeEnvAppName) {
+        return nodeEnvAppName;
+      }
+      
       // Priority 3: Default fallback
       return 'PACE';
     };
@@ -80,7 +96,7 @@ export function useAppConfig(): UseAppConfigReturn {
       requiresEvent: true, // Public pages always require an event
       isLoading: false,
       appName: getAppName()
-    }), [contextAppName]);
+    }), [contextAppName, hasPublicContext]);
   }
   
   // For authenticated pages, use UnifiedAuthProvider
@@ -98,7 +114,10 @@ export function useAppConfig(): UseAppConfigReturn {
       supportsDirectAccess: false,
       requiresEvent: true,
       isLoading: false,
-      appName: 'PACE'
-    }), []);
+      appName: contextAppName ||
+        getNodeEnvVar('VITE_APP_NAME') ||
+        getNodeEnvVar('NEXT_PUBLIC_APP_NAME') ||
+        'PACE'
+    }), [contextAppName]);
   }
 }