@jmruthers/pace-core 0.5.109 → 0.5.111

package/dist/{chunk-2W4WKJVF.js → chunk-X7SPKHYZ.js}

@@ -1,17 +1,17 @@
 import {
   init_useOrganisations,
   useOrganisations
-} from "./chunk-EZ64QG2I.js";
+} from "./chunk-I5YM5BGS.js";
 import {
   init_UnifiedAuthProvider
-} from "./chunk-EYSXQ756.js";
+} from "./chunk-TDFBX7KJ.js";
 import {
   OrganisationServiceContext,
   OrganisationServiceProvider,
   init_OrganisationServiceProvider,
   useOrganisationService,
   useUnifiedAuth
-} from "./chunk-AUXS7XSO.js";
+} from "./chunk-MW73E7SP.js";
 import {
   init_organisationContext,
   setOrganisationContext
@@ -651,244 +651,8 @@ async function archiveFile(supabase, path, options) {
   }
 }
 
-// src/hooks/public/usePublicFileDisplay.ts
-import { useState, useEffect, useCallback } from "react";
-var publicFileCache = /* @__PURE__ */ new Map();
-function usePublicFileDisplay(table_name, record_id, organisation_id, category, options) {
-  const {
-    cacheTtl = 30 * 60 * 1e3,
-    // 30 minutes
-    enableCache = true,
-    supabase
-  } = options;
-  const [fileUrl, setFileUrl] = useState(null);
-  const [fileReference, setFileReference] = useState(null);
-  const [fileReferences, setFileReferences] = useState([]);
-  const [fileUrls, setFileUrls] = useState(/* @__PURE__ */ new Map());
-  const [fileCount, setFileCount] = useState(0);
-  const [isLoading, setIsLoading] = useState(false);
-  const [error, setError] = useState(null);
-  const fetchFiles = useCallback(async () => {
-    if (!table_name || !record_id || !organisation_id || !supabase) {
-      setFileUrl(null);
-      setFileReference(null);
-      setFileReferences([]);
-      setFileUrls(/* @__PURE__ */ new Map());
-      setFileCount(0);
-      setIsLoading(false);
-      return;
-    }
-    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)) {
-      console.warn("[usePublicFileDisplay] Invalid organisationId format (not a valid UUID):", organisation_id);
-    }
-    const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
-    if (enableCache) {
-      const cached = publicFileCache.get(cacheKey);
-      if (cached && Date.now() - cached.timestamp < cached.ttl) {
-        const cachedData = cached.data;
-        setFileUrl(cachedData.fileUrl || null);
-        setFileReference(cachedData.fileReference || null);
-        setFileReferences(cachedData.fileReferences || []);
-        setFileUrls(cachedData.fileUrls || /* @__PURE__ */ new Map());
-        setFileCount(cachedData.fileCount || 0);
-        setIsLoading(false);
-        setError(null);
-        return;
-      }
-    }
-    try {
-      setIsLoading(true);
-      setError(null);
-      let files = [];
-      if (category) {
-        console.log("[usePublicFileDisplay] Using RPC function for category filtering:", {
-          table_name,
-          record_id,
-          category,
-          organisation_id
-        });
-        const { data, error: rpcError } = await supabase.rpc("data_file_reference_by_category_list", {
-          p_table_name: table_name,
-          p_record_id: record_id,
-          p_category: category,
-          p_organisation_id: organisation_id
-        });
-        if (rpcError) {
-          throw new Error(rpcError.message || "Failed to fetch file reference");
-        }
-        if (!data || data.length === 0) {
-          files = [];
-        } else {
-          files = data.filter((item) => {
-            return item.is_public === true && item.id && item.file_path && item.file_metadata;
-          }).map((item) => {
-            return {
-              id: item.id,
-              table_name,
-              record_id,
-              file_path: item.file_path,
-              file_metadata: item.file_metadata || {},
-              organisation_id,
-              app_id: item.file_metadata?.app_id || null,
-              is_public: true,
-              // RPC already filtered for public files
-              created_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString(),
-              updated_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString()
-            };
-          });
-        }
-      } else {
-        const { data: fileIds, error: rpcError } = await supabase.rpc("data_file_reference_list", {
-          p_table_name: table_name,
-          p_record_id: record_id,
-          p_organisation_id: organisation_id
-        });
-        if (rpcError) {
-          throw new Error(rpcError.message || "Failed to fetch file references");
-        }
-        if (!fileIds || fileIds.length === 0) {
-          files = [];
-        } else {
-          const ids = fileIds.map((item) => item.id);
-          const { data: fullData, error: fetchError } = await supabase.from("file_references").select("*").in("id", ids).eq("is_public", true);
-          if (fetchError) {
-            throw new Error(fetchError.message || "Failed to fetch file references");
-          }
-          files = fullData || [];
-        }
-      }
-      const publicFiles = files.filter((f) => f.is_public === true);
-      if (publicFiles.length === 0) {
-        setFileUrl(null);
-        setFileReference(null);
-        setFileReferences([]);
-        setFileUrls(/* @__PURE__ */ new Map());
-        setFileCount(0);
-        if (enableCache) {
-          publicFileCache.set(cacheKey, {
-            data: { fileUrl: null, fileReference: null, fileReferences: [], fileUrls: /* @__PURE__ */ new Map(), fileCount: 0 },
-            timestamp: Date.now(),
-            ttl: cacheTtl
-          });
-        }
-        return;
-      }
-      const fileRefs = publicFiles.map((f) => ({
-        id: f.id,
-        table_name: f.table_name,
-        record_id: f.record_id,
-        file_path: f.file_path,
-        file_metadata: f.file_metadata || {},
-        organisation_id: f.organisation_id,
-        app_id: f.app_id,
-        is_public: f.is_public ?? true,
-        created_at: f.created_at,
-        updated_at: f.updated_at
-      }));
-      setFileReferences(fileRefs);
-      setFileCount(fileRefs.length);
-      if (category && fileRefs.length > 0) {
-        const firstFile = fileRefs[0];
-        setFileReference(firstFile);
-        const url = getPublicUrl(supabase, firstFile.file_path, true);
-        setFileUrl(url);
-      } else {
-        const urlMap = /* @__PURE__ */ new Map();
-        for (const fileRef of fileRefs) {
-          const url = getPublicUrl(supabase, fileRef.file_path, true);
-          if (url) {
-            urlMap.set(fileRef.id, url);
-          }
-        }
-        setFileUrls(urlMap);
-        setFileReference(null);
-        setFileUrl(null);
-      }
-      if (enableCache) {
-        publicFileCache.set(cacheKey, {
-          data: {
-            fileUrl: category ? fileRefs.length > 0 ? getPublicUrl(supabase, fileRefs[0].file_path, true) : null : null,
-            fileReference: category && fileRefs.length > 0 ? fileRefs[0] : null,
-            fileReferences: fileRefs,
-            fileUrls: category ? /* @__PURE__ */ new Map() : (() => {
-              const urlMap = /* @__PURE__ */ new Map();
-              for (const fileRef of fileRefs) {
-                const url = getPublicUrl(supabase, fileRef.file_path, true);
-                if (url) {
-                  urlMap.set(fileRef.id, url);
-                }
-              }
-              return urlMap;
-            })(),
-            fileCount: fileRefs.length
-          },
-          timestamp: Date.now(),
-          ttl: cacheTtl
-        });
-      }
-    } catch (err) {
-      console.error("[usePublicFileDisplay] Error fetching files:", err);
-      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
-      setError(error2);
-      setFileUrl(null);
-      setFileReference(null);
-      setFileReferences([]);
-      setFileUrls(/* @__PURE__ */ new Map());
-      setFileCount(0);
-    } finally {
-      setIsLoading(false);
-    }
-  }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
-  useEffect(() => {
-    if (table_name && record_id && organisation_id) {
-      fetchFiles();
-    } else {
-      setFileUrl(null);
-      setFileReference(null);
-      setFileReferences([]);
-      setFileUrls(/* @__PURE__ */ new Map());
-      setFileCount(0);
-      setIsLoading(false);
-      setError(null);
-    }
-  }, [fetchFiles, table_name, record_id, organisation_id]);
-  const refetch = useCallback(async () => {
-    if (!table_name || !record_id || !organisation_id) return;
-    if (enableCache) {
-      const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
-      publicFileCache.delete(cacheKey);
-    }
-    await fetchFiles();
-  }, [fetchFiles, table_name, record_id, organisation_id, category, enableCache]);
-  return {
-    fileUrl,
-    fileReference,
-    fileReferences,
-    fileUrls,
-    fileCount,
-    isLoading,
-    error,
-    refetch
-  };
-}
-function clearPublicFileDisplayCache() {
-  for (const [key] of publicFileCache) {
-    if (key.startsWith("public_file_")) {
-      publicFileCache.delete(key);
-    }
-  }
-}
-function getPublicFileDisplayCacheStats() {
-  const keys = Array.from(publicFileCache.keys()).filter((key) => key.startsWith("public_file_"));
-  return {
-    size: keys.length,
-    keys
-  };
-}
-
 // src/hooks/useFileDisplay.ts
-import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+import { useState, useEffect, useCallback } from "react";
 
 // src/utils/file-reference.ts
 init_organisationContext();
@@ -966,6 +730,12 @@ var FileReferenceServiceImpl = class {
       if (fetchError || !fileRef) {
         throw new Error(`Failed to fetch created file reference: ${fetchError?.message}`);
       }
+      invalidateFileDisplayCache(
+        options.table_name,
+        options.record_id,
+        options.organisation_id,
+        options.category
+      );
       return fileRef;
     } catch (error) {
       console.error("Error creating file reference:", error);
@@ -1281,14 +1051,14 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
     enableCache = true,
     supabase
   } = options;
-  const [fileUrl, setFileUrl] = useState2(null);
-  const [fileReference, setFileReference] = useState2(null);
-  const [fileReferences, setFileReferences] = useState2([]);
-  const [fileUrls, setFileUrls] = useState2(/* @__PURE__ */ new Map());
-  const [fileCount, setFileCount] = useState2(0);
-  const [isLoading, setIsLoading] = useState2(false);
-  const [error, setError] = useState2(null);
-  const fetchFiles = useCallback2(async () => {
+  const [fileUrl, setFileUrl] = useState(null);
+  const [fileReference, setFileReference] = useState(null);
+  const [fileReferences, setFileReferences] = useState([]);
+  const [fileUrls, setFileUrls] = useState(/* @__PURE__ */ new Map());
+  const [fileCount, setFileCount] = useState(0);
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetchFiles = useCallback(async () => {
     if (!table_name || !record_id || !organisation_id || !supabase) {
       setFileUrl(null);
       setFileReference(null);
@@ -1307,6 +1077,26 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
       const cached = authenticatedFileCache.get(cacheKey);
       if (cached && Date.now() - cached.timestamp < cached.ttl) {
         const cachedData = cached.data;
+        if (cachedData.fileReference && !cachedData.fileUrl && cachedData.fileReference.is_public === false && supabase) {
+          try {
+            const signedUrlResult = await getSignedUrl(supabase, cachedData.fileReference.file_path, {
+              appName: "pace-core",
+              orgId: organisation_id,
+              expiresIn: 3600
+            });
+            const regeneratedUrl = signedUrlResult?.url || null;
+            setFileUrl(regeneratedUrl);
+            setFileReference(cachedData.fileReference);
+            setFileReferences(cachedData.fileReferences || []);
+            setFileUrls(cachedData.fileUrls || /* @__PURE__ */ new Map());
+            setFileCount(cachedData.fileCount || 0);
+            setIsLoading(false);
+            setError(null);
+            return;
+          } catch (err) {
+            console.warn("[useFileDisplay] Failed to regenerate signed URL from cache, falling back to fetch:", err);
+          }
+        }
         setFileUrl(cachedData.fileUrl || null);
         setFileReference(cachedData.fileReference || null);
         setFileReferences(cachedData.fileReferences || []);
@@ -1453,7 +1243,7 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
       setIsLoading(false);
     }
   }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
-  useEffect2(() => {
+  useEffect(() => {
     if (table_name && record_id && organisation_id && supabase) {
       fetchFiles();
     } else {
@@ -1466,7 +1256,7 @@ function useFileDisplay(table_name, record_id, organisation_id, category, option
       setError(null);
     }
   }, [fetchFiles, table_name, record_id, organisation_id, supabase]);
-  const refetch = useCallback2(async () => {
+  const refetch = useCallback(async () => {
     if (!table_name || !record_id || !organisation_id || !supabase) return;
     if (enableCache) {
       const cacheKey = `file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
@@ -1499,6 +1289,250 @@ function getFileDisplayCacheStats() {
     keys
   };
 }
+function invalidateFileDisplayCache(table_name, record_id, organisation_id, category) {
+  const cacheKey = `file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+  authenticatedFileCache.delete(cacheKey);
+  if (category) {
+    const allCategoryKey = `file_${table_name}_${record_id}_${organisation_id}_all`;
+    authenticatedFileCache.delete(allCategoryKey);
+  }
+}
+
+// src/hooks/public/usePublicFileDisplay.ts
+import { useState as useState2, useEffect as useEffect2, useCallback as useCallback2 } from "react";
+var publicFileCache = /* @__PURE__ */ new Map();
+function usePublicFileDisplay(table_name, record_id, organisation_id, category, options) {
+  const {
+    cacheTtl = 30 * 60 * 1e3,
+    // 30 minutes
+    enableCache = true,
+    supabase
+  } = options;
+  const [fileUrl, setFileUrl] = useState2(null);
+  const [fileReference, setFileReference] = useState2(null);
+  const [fileReferences, setFileReferences] = useState2([]);
+  const [fileUrls, setFileUrls] = useState2(/* @__PURE__ */ new Map());
+  const [fileCount, setFileCount] = useState2(0);
+  const [isLoading, setIsLoading] = useState2(false);
+  const [error, setError] = useState2(null);
+  const fetchFiles = useCallback2(async () => {
+    if (!table_name || !record_id || !organisation_id || !supabase) {
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+      setIsLoading(false);
+      return;
+    }
+    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)) {
+      console.warn("[usePublicFileDisplay] Invalid organisationId format (not a valid UUID):", organisation_id);
+    }
+    const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+    if (enableCache) {
+      const cached = publicFileCache.get(cacheKey);
+      if (cached && Date.now() - cached.timestamp < cached.ttl) {
+        const cachedData = cached.data;
+        setFileUrl(cachedData.fileUrl || null);
+        setFileReference(cachedData.fileReference || null);
+        setFileReferences(cachedData.fileReferences || []);
+        setFileUrls(cachedData.fileUrls || /* @__PURE__ */ new Map());
+        setFileCount(cachedData.fileCount || 0);
+        setIsLoading(false);
+        setError(null);
+        return;
+      }
+    }
+    try {
+      setIsLoading(true);
+      setError(null);
+      let files = [];
+      if (category) {
+        console.log("[usePublicFileDisplay] Using RPC function for category filtering:", {
+          table_name,
+          record_id,
+          category,
+          organisation_id
+        });
+        const { data, error: rpcError } = await supabase.rpc("data_file_reference_by_category_list", {
+          p_table_name: table_name,
+          p_record_id: record_id,
+          p_category: category,
+          p_organisation_id: organisation_id
+        });
+        if (rpcError) {
+          throw new Error(rpcError.message || "Failed to fetch file reference");
+        }
+        if (!data || data.length === 0) {
+          files = [];
+        } else {
+          files = data.filter((item) => {
+            return item.is_public === true && item.id && item.file_path && item.file_metadata;
+          }).map((item) => {
+            return {
+              id: item.id,
+              table_name,
+              record_id,
+              file_path: item.file_path,
+              file_metadata: item.file_metadata || {},
+              organisation_id,
+              app_id: item.file_metadata?.app_id || null,
+              is_public: true,
+              // RPC already filtered for public files
+              created_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString(),
+              updated_at: item.created_at || (/* @__PURE__ */ new Date()).toISOString()
+            };
+          });
+        }
+      } else {
+        const { data: fileIds, error: rpcError } = await supabase.rpc("data_file_reference_list", {
+          p_table_name: table_name,
+          p_record_id: record_id,
+          p_organisation_id: organisation_id
+        });
+        if (rpcError) {
+          throw new Error(rpcError.message || "Failed to fetch file references");
+        }
+        if (!fileIds || fileIds.length === 0) {
+          files = [];
+        } else {
+          const ids = fileIds.map((item) => item.id);
+          const { data: fullData, error: fetchError } = await supabase.from("file_references").select("*").in("id", ids).eq("is_public", true);
+          if (fetchError) {
+            throw new Error(fetchError.message || "Failed to fetch file references");
+          }
+          files = fullData || [];
+        }
+      }
+      const publicFiles = files.filter((f) => f.is_public === true);
+      if (publicFiles.length === 0) {
+        setFileUrl(null);
+        setFileReference(null);
+        setFileReferences([]);
+        setFileUrls(/* @__PURE__ */ new Map());
+        setFileCount(0);
+        if (enableCache) {
+          publicFileCache.set(cacheKey, {
+            data: { fileUrl: null, fileReference: null, fileReferences: [], fileUrls: /* @__PURE__ */ new Map(), fileCount: 0 },
+            timestamp: Date.now(),
+            ttl: cacheTtl
+          });
+        }
+        return;
+      }
+      const fileRefs = publicFiles.map((f) => ({
+        id: f.id,
+        table_name: f.table_name,
+        record_id: f.record_id,
+        file_path: f.file_path,
+        file_metadata: f.file_metadata || {},
+        organisation_id: f.organisation_id,
+        app_id: f.app_id,
+        is_public: f.is_public ?? true,
+        created_at: f.created_at,
+        updated_at: f.updated_at
+      }));
+      setFileReferences(fileRefs);
+      setFileCount(fileRefs.length);
+      if (category && fileRefs.length > 0) {
+        const firstFile = fileRefs[0];
+        setFileReference(firstFile);
+        const url = getPublicUrl(supabase, firstFile.file_path, true);
+        setFileUrl(url);
+      } else {
+        const urlMap = /* @__PURE__ */ new Map();
+        for (const fileRef of fileRefs) {
+          const url = getPublicUrl(supabase, fileRef.file_path, true);
+          if (url) {
+            urlMap.set(fileRef.id, url);
+          }
+        }
+        setFileUrls(urlMap);
+        setFileReference(null);
+        setFileUrl(null);
+      }
+      if (enableCache) {
+        publicFileCache.set(cacheKey, {
+          data: {
+            fileUrl: category ? fileRefs.length > 0 ? getPublicUrl(supabase, fileRefs[0].file_path, true) : null : null,
+            fileReference: category && fileRefs.length > 0 ? fileRefs[0] : null,
+            fileReferences: fileRefs,
+            fileUrls: category ? /* @__PURE__ */ new Map() : (() => {
+              const urlMap = /* @__PURE__ */ new Map();
+              for (const fileRef of fileRefs) {
+                const url = getPublicUrl(supabase, fileRef.file_path, true);
+                if (url) {
+                  urlMap.set(fileRef.id, url);
+                }
+              }
+              return urlMap;
+            })(),
+            fileCount: fileRefs.length
+          },
+          timestamp: Date.now(),
+          ttl: cacheTtl
+        });
+      }
+    } catch (err) {
+      console.error("[usePublicFileDisplay] Error fetching files:", err);
+      const error2 = err instanceof Error ? err : new Error("Unknown error occurred");
+      setError(error2);
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [table_name, record_id, organisation_id, category, supabase, cacheTtl, enableCache]);
+  useEffect2(() => {
+    if (table_name && record_id && organisation_id) {
+      fetchFiles();
+    } else {
+      setFileUrl(null);
+      setFileReference(null);
+      setFileReferences([]);
+      setFileUrls(/* @__PURE__ */ new Map());
+      setFileCount(0);
+      setIsLoading(false);
+      setError(null);
+    }
+  }, [fetchFiles, table_name, record_id, organisation_id]);
+  const refetch = useCallback2(async () => {
+    if (!table_name || !record_id || !organisation_id) return;
+    if (enableCache) {
+      const cacheKey = `public_file_${table_name}_${record_id}_${organisation_id}_${category || "all"}`;
+      publicFileCache.delete(cacheKey);
+    }
+    await fetchFiles();
+  }, [fetchFiles, table_name, record_id, organisation_id, category, enableCache]);
+  return {
+    fileUrl,
+    fileReference,
+    fileReferences,
+    fileUrls,
+    fileCount,
+    isLoading,
+    error,
+    refetch
+  };
+}
+function clearPublicFileDisplayCache() {
+  for (const [key] of publicFileCache) {
+    if (key.startsWith("public_file_")) {
+      publicFileCache.delete(key);
+    }
+  }
+}
+function getPublicFileDisplayCacheStats() {
+  const keys = Array.from(publicFileCache.keys()).filter((key) => key.startsWith("public_file_"));
+  return {
+    size: keys.length,
+    keys
+  };
+}
 
 export {
   OrganisationProvider_exports,
@@ -1528,13 +1562,14 @@ export {
   listFiles,
   downloadFile,
   archiveFile,
+  useFileDisplay,
+  clearFileDisplayCache,
+  getFileDisplayCacheStats,
+  invalidateFileDisplayCache,
   createFileReferenceService,
   uploadFileWithReference,
   usePublicFileDisplay,
   clearPublicFileDisplayCache,
-  getPublicFileDisplayCacheStats,
-  useFileDisplay,
-  clearFileDisplayCache,
-  getFileDisplayCacheStats
+  getPublicFileDisplayCacheStats
 };
-//# sourceMappingURL=chunk-2W4WKJVF.js.map
+//# sourceMappingURL=chunk-X7SPKHYZ.js.map