Merge pull request #217 from OpenMined/madhava/facet-subselect

Madhava/facet subselect

Author: madhavajay

.github/workflows/release.yml

@@ -21,7 +21,7 @@ on:
       build_macos_x64:
         description: "Build macOS (Intel)"
         required: false
-        default: false
+        default: true
         type: boolean
       build_windows_x64:
         description: "Build Windows (x86_64)"
@@ -31,12 +31,12 @@ on:
       build_linux_x64:
         description: "Build Linux (x86_64)"
         required: false
-        default: false
+        default: true
         type: boolean
       build_linux_arm64:
         description: "Build Linux (arm64, no bundled deps)"
         required: false
-        default: false
+        default: true
         type: boolean
   workflow_call:
     inputs:
@@ -54,19 +54,19 @@ on:
       build_macos_x64:
         required: false
         type: boolean
-        default: false
+        default: true
       build_windows_x64:
         required: false
         type: boolean
         default: true
       build_linux_x64:
         required: false
         type: boolean
-        default: false
+        default: true
       build_linux_arm64:
         required: false
         type: boolean
-        default: false
+        default: true
 
 concurrency:
   group: release-${{ github.ref_name }}

src-tauri/src/commands/files/crud.rs

@@ -91,7 +91,9 @@ fn sources_for_file_ids(
         .map_err(|e| format!("Failed to prepare source lookup: {}", e))?;
 
     let rows = stmt
-        .query_map([], |row| Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?)))
+        .query_map([], |row| {
+            Ok((row.get::<_, i64>(0)?, row.get::<_, String>(1)?))
+        })
         .map_err(|e| format!("Failed to read source lookup: {}", e))?;
     for row in rows {
         let (file_id, source) = row.map_err(|e| format!("Failed to collect sources: {}", e))?;

src-tauri/src/commands/files/facets.rs

@@ -239,7 +239,12 @@ pub fn import_participant_facets(
         ) {
             Ok(id) => id,
             Err(rusqlite::Error::QueryReturnedNoRows) => continue,
-            Err(e) => return Err(format!("Failed to look up participant {}: {}", participant, e)),
+            Err(e) => {
+                return Err(format!(
+                    "Failed to look up participant {}: {}",
+                    participant, e
+                ))
+            }
         };
 
         tx.execute(

src-tauri/src/commands/flows.rs

@@ -442,6 +442,100 @@ fn copy_local_flow_dir(src: &Path, dest: &Path) -> Result<(), String> {
     Ok(())
 }
 
+fn remove_existing_path(path: &Path, label: &str) -> Result<(), String> {
+    let metadata = match fs::symlink_metadata(path) {
+        Ok(metadata) => metadata,
+        Err(e) if e.kind() == std::io::ErrorKind::NotFound => return Ok(()),
+        Err(e) => {
+            return Err(format!(
+                "Failed to inspect {} {}: {}",
+                label,
+                path.display(),
+                e
+            ))
+        }
+    };
+
+    let file_type = metadata.file_type();
+    if file_type.is_dir() && !file_type.is_symlink() {
+        fs::remove_dir_all(path)
+    } else {
+        fs::remove_file(path)
+    }
+    .map_err(|e| {
+        format!(
+            "Failed to remove existing {} {}: {}",
+            label,
+            path.display(),
+            e
+        )
+    })
+}
+
+fn path_exists_or_symlink(path: &Path) -> bool {
+    fs::symlink_metadata(path).is_ok()
+}
+
+fn path_has_wildcard(path: &str) -> bool {
+    path.contains('*') || path.contains('?')
+}
+
+fn wildcard_match(pattern: &str, value: &str) -> bool {
+    let pattern_chars: Vec<char> = pattern.chars().collect();
+    let value_chars: Vec<char> = value.chars().collect();
+    let mut pattern_idx = 0;
+    let mut value_idx = 0;
+    let mut star_idx: Option<usize> = None;
+    let mut star_value_idx = 0;
+
+    while value_idx < value_chars.len() {
+        if pattern_idx < pattern_chars.len()
+            && (pattern_chars[pattern_idx] == '?'
+                || pattern_chars[pattern_idx] == value_chars[value_idx])
+        {
+            pattern_idx += 1;
+            value_idx += 1;
+        } else if pattern_idx < pattern_chars.len() && pattern_chars[pattern_idx] == '*' {
+            star_idx = Some(pattern_idx);
+            pattern_idx += 1;
+            star_value_idx = value_idx;
+        } else if let Some(star) = star_idx {
+            pattern_idx = star + 1;
+            star_value_idx += 1;
+            value_idx = star_value_idx;
+        } else {
+            return false;
+        }
+    }
+
+    while pattern_idx < pattern_chars.len() && pattern_chars[pattern_idx] == '*' {
+        pattern_idx += 1;
+    }
+
+    pattern_idx == pattern_chars.len()
+}
+
+fn normalized_path_string(path: &Path) -> String {
+    path.to_string_lossy().replace('\\', "/")
+}
+
+fn wildcard_search_root(path: &Path) -> PathBuf {
+    let mut root = PathBuf::new();
+    for component in path.components() {
+        let component_text = component.as_os_str().to_string_lossy();
+        if path_has_wildcard(&component_text) {
+            break;
+        }
+        root.push(component.as_os_str());
+    }
+
+    if root.as_os_str().is_empty() {
+        PathBuf::from(".")
+    } else {
+        root
+    }
+}
+
 fn list_nextflow_locks(flow_path: &Path) -> Vec<PathBuf> {
     let nextflow_dir = flow_path.join(".nextflow");
     if !nextflow_dir.exists() {
@@ -1609,10 +1703,9 @@ pub async fn create_flow(
         // Create flow directory in managed location
         let managed_flow_dir = flows_dir.join(&name);
 
-        if managed_flow_dir.exists() {
+        if path_exists_or_symlink(&managed_flow_dir) {
             if overwrite {
-                fs::remove_dir_all(&managed_flow_dir)
-                    .map_err(|e| format!("Failed to remove existing flow directory: {}", e))?;
+                remove_existing_path(&managed_flow_dir, "flow directory")?;
             } else {
                 return Err(format!(
                     "Flow '{}' already exists at {}. Use overwrite to replace.",
@@ -1649,15 +1742,9 @@ pub async fn create_flow(
                 let module_dir_name = entry.file_name().to_string_lossy().to_string();
                 let dest_module_dir = modules_dir.join(&module_dir_name);
 
-                if dest_module_dir.exists() {
+                if path_exists_or_symlink(&dest_module_dir) {
                     if overwrite {
-                        fs::remove_dir_all(&dest_module_dir).map_err(|e| {
-                            format!(
-                                "Failed to remove existing module directory {}: {}",
-                                dest_module_dir.display(),
-                                e
-                            )
-                        })?;
+                        remove_existing_path(&dest_module_dir, "module directory")?;
                     } else {
                         continue;
                     }
@@ -1897,9 +1984,8 @@ pub async fn import_flow_from_json(
             .map_err(|e| e.to_string())?;
     }
 
-    if flow_dir.exists() && overwrite {
-        fs::remove_dir_all(&flow_dir)
-            .map_err(|e| format!("Failed to remove existing flow directory: {}", e))?;
+    if overwrite {
+        remove_existing_path(&flow_dir, "flow directory")?;
     }
 
     fs::create_dir_all(&flow_dir).map_err(|e| format!("Failed to create flow directory: {}", e))?;
@@ -2068,9 +2154,8 @@ pub async fn delete_flow(state: tauri::State<'_, AppState>, flow_id: i64) -> Res
         let path_buf = PathBuf::from(p.flow_path);
 
         // Only delete if the path is within the flows directory
-        if path_buf.starts_with(&flows_dir) && path_buf.exists() {
-            fs::remove_dir_all(&path_buf)
-                .map_err(|e| format!("Failed to delete flow directory: {}", e))?;
+        if path_buf.starts_with(&flows_dir) && path_exists_or_symlink(&path_buf) {
+            remove_existing_path(&path_buf, "flow directory")?;
         }
     }
 
@@ -3873,9 +3958,49 @@ pub fn get_flow_run_logs_full(
 
 #[tauri::command]
 pub fn path_exists(path: String) -> Result<bool, String> {
+    if path_has_wildcard(&path) {
+        return Ok(!resolve_path_matches(path)?.is_empty());
+    }
     Ok(Path::new(&path).exists())
 }
 
+#[tauri::command]
+pub fn resolve_path_matches(path: String) -> Result<Vec<String>, String> {
+    if !path_has_wildcard(&path) {
+        let path_buf = PathBuf::from(&path);
+        return Ok(if path_buf.exists() {
+            vec![path]
+        } else {
+            Vec::new()
+        });
+    }
+
+    let pattern_path = PathBuf::from(&path);
+    let search_root = wildcard_search_root(&pattern_path);
+    if !search_root.exists() {
+        return Ok(Vec::new());
+    }
+
+    let normalized_pattern = path.replace('\\', "/");
+    let mut matches = Vec::new();
+    for entry in WalkDir::new(&search_root)
+        .follow_links(false)
+        .into_iter()
+        .filter_map(Result::ok)
+    {
+        if !entry.file_type().is_file() {
+            continue;
+        }
+        let candidate = normalized_path_string(entry.path());
+        if wildcard_match(&normalized_pattern, &candidate) {
+            matches.push(entry.path().to_string_lossy().to_string());
+        }
+    }
+    matches.sort();
+    matches.dedup();
+    Ok(matches)
+}
+
 #[tauri::command]
 pub fn get_flow_run_work_dir(state: tauri::State<AppState>, run_id: i64) -> Result<String, String> {
     let biovault_db = state.biovault_db.lock().map_err(|e| e.to_string())?;
@@ -3999,11 +4124,10 @@ pub async fn import_flow_from_message(
     let flow_dir = flows_dir.join(&name);
 
     // Check if flow already exists
-    if flow_dir.exists() {
+    if path_exists_or_symlink(&flow_dir) {
         // For now, we'll overwrite - in the future could prompt user
         // or rename with version suffix
-        fs::remove_dir_all(&flow_dir)
-            .map_err(|e| format!("Failed to remove existing flow: {}", e))?;
+        remove_existing_path(&flow_dir, "flow directory")?;
     }
 
     // Create flow directory
@@ -4170,10 +4294,9 @@ pub async fn import_flow_from_request(
             .map_err(|e| e.to_string())?;
     }
 
-    if dest_dir.exists() {
+    if path_exists_or_symlink(&dest_dir) {
         if overwrite {
-            fs::remove_dir_all(&dest_dir)
-                .map_err(|e| format!("Failed to remove existing flow: {}", e))?;
+            remove_existing_path(&dest_dir, "flow directory")?;
         } else {
             return Err(format!(
                 "Flow '{}' already exists at {}. Use overwrite to replace.",
@@ -4203,15 +4326,9 @@ pub async fn import_flow_from_request(
             let module_dir_name = entry.file_name().to_string_lossy().to_string();
             let dest_module_dir = modules_dir.join(&module_dir_name);
 
-            if dest_module_dir.exists() {
+            if path_exists_or_symlink(&dest_module_dir) {
                 if overwrite {
-                    fs::remove_dir_all(&dest_module_dir).map_err(|e| {
-                        format!(
-                            "Failed to remove existing module directory {}: {}",
-                            dest_module_dir.display(),
-                            e
-                        )
-                    })?;
+                    remove_existing_path(&dest_module_dir, "module directory")?;
                 } else {
                     continue;
                 }

src-tauri/src/lib.rs

@@ -1749,6 +1749,7 @@ pub fn run() {
             resume_flow_run,
             cleanup_flow_run_state,
             path_exists,
+            resolve_path_matches,
             delete_flow_run,
             preview_flow_spec,
             import_flow_from_message,

src-tauri/src/ws_bridge.rs

@@ -452,6 +452,7 @@ fn get_commands_list() -> serde_json::Value {
         cmd("cleanup_flow_run_state", "flows", true),
         cmd("get_flow_run_work_dir", "flows", true),
         cmd("path_exists", "flows", true),
+        cmd("resolve_path_matches", "flows", true),
         cmd("start_analysis", "runs", false),
         cmd_async("execute_analysis", "runs", false),
         // Sessions
@@ -1345,6 +1346,17 @@ async fn execute_command(app: &AppHandle, cmd: &str, args: Value) -> Result<Valu
             let result = crate::commands::flows::path_exists(path).map_err(|e| e.to_string())?;
             Ok(serde_json::to_value(result).unwrap())
         }
+        "resolve_path_matches" => {
+            let path: String = serde_json::from_value(
+                args.get("path")
+                    .cloned()
+                    .ok_or_else(|| "Missing path".to_string())?,
+            )
+            .map_err(|e| format!("Failed to parse path: {}", e))?;
+            let result =
+                crate::commands::flows::resolve_path_matches(path).map_err(|e| e.to_string())?;
+            Ok(serde_json::to_value(result).unwrap())
+        }
         "get_flow_run_logs" => {
             let run_id: i64 = serde_json::from_value(
                 args.get("runId")

src/data.js

@@ -911,7 +911,9 @@ export function createDataModule({ invoke, dialog, getCurrentUserEmail }) {
 	function pruneSourceFilter(options) {
 		if (!activeSourceFilters) return
 		const validValues = new Set(options.map(([value]) => value))
-		const selected = new Set(Array.from(activeSourceFilters).filter((value) => validValues.has(value)))
+		const selected = new Set(
+			Array.from(activeSourceFilters).filter((value) => validValues.has(value)),
+		)
 		if (selected.size === validValues.size) {
 			activeSourceFilters = null
 		} else {
@@ -940,9 +942,7 @@ export function createDataModule({ invoke, dialog, getCurrentUserEmail }) {
 		const selectedValues = getSelectedSourceValues(options)
 		const selectedCount = options.filter(([value]) => selectedValues.has(value)).length
 		const allChecked = selectedCount === options.length
-		const summaryLabel = allChecked
-			? 'Source: All'
-			: `Source: ${selectedCount}/${options.length}`
+		const summaryLabel = allChecked ? 'Source: All' : `Source: ${selectedCount}/${options.length}`
 		const optionItems = options
 			.map(([value, count]) => {
 				const inputId = `data-source-filter-${value}`.replace(/[^a-zA-Z0-9_-]/g, '_')