Merge pull request #4 from solid/feat/my-storages

Added hierarchical traversal function to useSolidStorages hook

Author: PreciousOritsedere

app/lib/hooks/useSolidStorages.ts

@@ -4,9 +4,11 @@ import { useEffect, useState } from "react";
 import { getDefaultSession } from "@inrupt/solid-client-authn-browser";
 import { Parser, Store, NamedNode, Literal } from "n3";
 
-// Storage predicates
+// Storage predicates and types
 const PIM_STORAGE = "http://www.w3.org/ns/pim/space#storage";
 const SOLID_STORAGE = "http://www.w3.org/ns/solid/terms#storage";
+const PIM_STORAGE_TYPE = "http://www.w3.org/ns/pim/space#Storage";
+const RDF_TYPE = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
 const FOAF_NAME = "http://xmlns.com/foaf/0.1/name";
 const VCARD_FN = "http://www.w3.org/2006/vcard/ns#fn";
 
@@ -22,9 +24,130 @@ interface UseSolidStoragesResult {
   error: Error | null;
 }
 
+/**
+ * Discovers storage by traversing up the folder hierarchy from the WebID
+ * Based on: https://github.com/SolidLabResearch/Bashlib/blob/80de25cbb4b3ed057f95e25bc057f1be9b00cef3/src/utils/util.ts#L73-L104
+ * @param {string} webId - The WebID to start traversal from
+ * @param {typeof fetch} fetchFn - The fetch function to use (should be authenticated)
+ * @returns {Promise<string[]>} - Array of storage URLs found via traversal
+ */
+async function discoverStorageViaTraversal(
+  webId: string,
+  fetchFn: typeof fetch
+): Promise<string[]> {
+  const storageUrls: string[] = [];
+  
+  try {
+    // Extract the base URL from the WebID (remove fragment)
+    const url = new URL(webId);
+    const baseUrl = `${url.origin}${url.pathname}`;
+    
+    // Start from the parent directory of the WebID
+    let currentUrl = baseUrl.substring(0, baseUrl.lastIndexOf('/') + 1);
+    
+    // Traverse up the hierarchy
+    const maxLevels = 10; // Prevent infinite loops
+    let level = 0;
+    
+    while (currentUrl && level < maxLevels) {
+      try {
+        console.log(`[Traversal] Checking container: ${currentUrl}`);
+        
+        // Fetch the container with content negotiation
+        const response = await fetchFn(currentUrl, {
+          method: 'GET',
+          headers: {
+            'Accept': 'text/turtle, application/ld+json, */*;q=0.1',
+          },
+        });
+        
+        if (!response.ok) {
+          console.log(`[Traversal] Container not accessible: ${response.status} ${response.statusText}`);
+          // Move up one level and continue
+          const parentUrl = currentUrl.substring(0, currentUrl.lastIndexOf('/', currentUrl.length - 2) + 1);
+          if (parentUrl === currentUrl || parentUrl === `${url.origin}/`) {
+            break; // Reached root
+          }
+          currentUrl = parentUrl;
+          level++;
+          continue;
+        }
+        
+        const contentType = response.headers.get('Content-Type') || '';
+        const content = await response.text();
+        
+        // Parse the RDF content
+        const store = new Store();
+        if (contentType.includes('text/turtle') || contentType.includes('application/turtle') || 
+            contentType.includes('text/n3') || contentType.includes('application/n3')) {
+          const parser = new Parser({ baseIRI: currentUrl });
+          const quads = parser.parse(content);
+          store.addQuads(quads);
+        } else {
+          // Try parsing as Turtle anyway (some servers don't set content-type correctly)
+          try {
+            const parser = new Parser({ baseIRI: currentUrl });
+            const quads = parser.parse(content);
+            store.addQuads(quads);
+          } catch (e) {
+            console.warn(`[Traversal] Failed to parse content from ${currentUrl}:`, e);
+            // Move up one level and continue
+            const parentUrl = currentUrl.substring(0, currentUrl.lastIndexOf('/', currentUrl.length - 2) + 1);
+            if (parentUrl === currentUrl || parentUrl === `${url.origin}/`) {
+              break;
+            }
+            currentUrl = parentUrl;
+            level++;
+            continue;
+          }
+        }
+        
+        const containerNode = new NamedNode(currentUrl);
+        const rdfType = new NamedNode(RDF_TYPE);
+        const pimStorageType = new NamedNode(PIM_STORAGE_TYPE);
+        
+        // Check if this container is of type pim:Storage
+        const typeQuads = store.getQuads(containerNode, rdfType, pimStorageType, null);
+        const isStorage = typeQuads.length > 0;
+        
+        if (isStorage) {
+          // Ensure URL ends with /
+          const storageUrl = currentUrl.endsWith('/') ? currentUrl : currentUrl + '/';
+          storageUrls.push(storageUrl);
+          console.log(`[Traversal] Found pim:Storage at: ${storageUrl}`);
+          break; // Found storage, no need to continue
+        }
+        
+        // Move up one level
+        const parentUrl = currentUrl.substring(0, currentUrl.lastIndexOf('/', currentUrl.length - 2) + 1);
+        if (parentUrl === currentUrl || parentUrl === `${url.origin}/`) {
+          break; // Reached root
+        }
+        currentUrl = parentUrl;
+        level++;
+      } catch (error) {
+        // If we can't fetch a container, try the parent
+        console.debug(`[Traversal] Could not fetch ${currentUrl}, trying parent:`, error);
+        const parentUrl = currentUrl.substring(0, currentUrl.lastIndexOf('/', currentUrl.length - 2) + 1);
+        if (parentUrl === currentUrl || parentUrl === `${url.origin}/`) {
+          break;
+        }
+        currentUrl = parentUrl;
+        level++;
+      }
+    }
+  } catch (error) {
+    console.error("[Traversal] Error discovering storage via traversal:", error);
+  }
+  
+  return storageUrls;
+}
+
 /**
  * Hook to fetch Solid storage roots from the user's WebID profile.
- * Uses direct RDF parsing to discover storage locations via pim:storage and solid:storage predicates.
+ * Uses two methods:
+ * 1. Direct RDF parsing to discover storage locations via pim:storage and solid:storage predicates
+ * 2. Hierarchical traversal to find pim:Storage containers by walking up the directory tree
  */
 export function useSolidStorages(): UseSolidStoragesResult {
   const [storages, setStorages] = useState<SolidStorage[]>([]);
@@ -383,9 +506,27 @@ export function useSolidStorages(): UseSolidStoragesResult {
         });
         console.log("=========================");
 
-        // If no storage found via predicates, try to infer from WebID
+        // Method 2: Hierarchical traversal (if no storage found via predicates)
+        // Based on: https://github.com/SolidLabResearch/Bashlib/blob/80de25cbb4b3ed057f95e25bc057f1be9b00cef3/src/utils/util.ts#L73-L104
+        if (storageUrls.length === 0) {
+          console.log("No storage found via predicates, attempting hierarchical traversal...");
+          
+          try {
+            const traversalStorages = await discoverStorageViaTraversal(webId, session.fetch || fetch);
+            traversalStorages.forEach(url => {
+              if (!storageUrls.includes(url)) {
+                storageUrls.push(url);
+                console.log("Found storage via hierarchical traversal:", url);
+              }
+            });
+          } catch (err) {
+            console.warn("Hierarchical traversal failed:", err);
+          }
+        }
+
+        // If still no storage found, try to infer from WebID
         if (storageUrls.length === 0) {
-          console.log("No storage found via predicates, attempting to infer from WebID...");
+          console.log("No storage found via predicates or traversal, attempting to infer from WebID...");
 
           // Extract base URL from WebID
           const webIdUrl = new URL(webId);