refactor(db): simplify database query builders

soar-cli/src/download.rs

@@ -80,7 +80,7 @@ pub async fn handle_direct_downloads(
     for link in &links {
         match PlatformUrl::parse(link) {
             Ok(PlatformUrl::DirectUrl(url)) => {
-                println!("Downloading using direct link: {}", url);
+                info!("Downloading using direct link: {}", url);
 
                 let options = DownloadOptions {
                     url: link.clone(),
@@ -93,7 +93,7 @@ pub async fn handle_direct_downloads(
                     .map_err(|e| eprintln!("{}", e));
             }
             Ok(PlatformUrl::Github(project)) => {
-                println!("Detected GitHub URL, processing as GitHub release");
+                info!("Detected GitHub URL, processing as GitHub release");
                 let handler = ReleaseHandler::<Github>::new();
                 if let Err(e) = handle_platform_download::<Github, GithubRelease, GithubAsset>(
                     ctx, &handler, &project,
@@ -104,7 +104,7 @@ pub async fn handle_direct_downloads(
                 }
             }
             Ok(PlatformUrl::Gitlab(project)) => {
-                println!("Detected GitLab URL, processing as GitLab release");
+                info!("Detected GitLab URL, processing as GitLab release");
                 let handler = ReleaseHandler::<Gitlab>::new();
                 if let Err(e) = handle_platform_download::<Gitlab, GitlabRelease, GitlabAsset>(
                     ctx, &handler, &project,
@@ -115,7 +115,7 @@ pub async fn handle_direct_downloads(
                 }
             }
             Ok(PlatformUrl::Oci(url)) => {
-                println!("Downloading using OCI reference: {}", url);
+                info!("Downloading using OCI reference: {}", url);
 
                 let options = DownloadOptions {
                     url: link.clone(),
@@ -148,7 +148,7 @@ pub async fn handle_oci_downloads(
             progress_callback: Some(progress_callback.clone()),
         };
 
-        println!("Downloading using OCI reference: {}", reference);
+        info!("Downloading using OCI reference: {}", reference);
         let _ = downloader
             .download_oci(options)
             .await

soar-cli/src/inspect.rs

@@ -3,10 +3,7 @@ use std::fmt::Display;
 use futures::StreamExt;
 use indicatif::HumanBytes;
 use soar_core::{
-    database::{
-        models::Package,
-        packages::{get_packages_with_filter, PackageFilter},
-    },
+    database::packages::{get_packages, QueryOptions},
     package::query::PackageQuery,
     SoarResult,
 };
@@ -33,29 +30,38 @@ pub async fn inspect_log(package: &str, inspect_type: InspectType) -> SoarResult
     let repo_db = state.repo_db().clone();
 
     let query = PackageQuery::try_from(package)?;
-    let filter = PackageFilter::from_query(query);
+    let filters = query.create_filter();
 
-    let packages: Vec<Package> = get_packages_with_filter(repo_db, 1024, filter)?
-        .into_iter()
-        .filter_map(Result::ok)
-        .collect();
+    let options = QueryOptions {
+        limit: 1,
+        filters,
+        ..Default::default()
+    };
 
-    if packages.is_empty() {
-        error!("Package {package} not found");
+    let packages = get_packages(repo_db, options)?;
+    if packages.items.is_empty() {
+        error!("Package {} not found", package);
     } else {
-        let first_pkg = packages.first().unwrap();
+        let first_pkg = packages.items.first().unwrap();
 
         let url = if matches!(inspect_type, InspectType::BuildLog) {
             &first_pkg.build_log
-        } else if first_pkg.build_script.starts_with("https://github.com") {
-            &first_pkg
-                .build_script
-                .replacen("/tree/", "/raw/refs/heads/", 1)
-                .replacen("/blob/", "/raw/refs/heads/", 1)
         } else {
             &first_pkg.build_script
         };
 
+        let Some(url) = url else {
+            error!("No build {} found for {}", inspect_type, first_pkg.pkg_name);
+            return Ok(());
+        };
+
+        let url = if url.starts_with("https://github.com") {
+            &url.replacen("/tree/", "/raw/refs/heads/", 1)
+                .replacen("/blob/", "/raw/refs/heads/", 1)
+        } else {
+            url
+        };
+
         let resp = reqwest::get(url).await?;
         if !resp.status().is_success() {
             error!(
@@ -92,5 +98,6 @@ pub async fn inspect_log(package: &str, inspect_type: InspectType) -> SoarResult
 
         info!("\n{}", output);
     }
+
     Ok(())
 }

soar-cli/src/install.rs

@@ -1,4 +1,5 @@
 use std::{
+    collections::HashMap,
     os::unix::fs,
     path::PathBuf,
     sync::{
@@ -14,7 +15,7 @@ use soar_core::{
     config::get_config,
     database::{
         models::{InstalledPackage, Package},
-        packages::{get_installed_packages_with_filter, get_packages_with_filter, PackageFilter},
+        packages::{get_installed_packages, get_packages, FilterOp, QueryOptions},
     },
     error::SoarError,
     package::{
@@ -106,9 +107,20 @@ fn resolve_packages(
 
     for package in packages {
         let query = PackageQuery::try_from(package.as_str())?;
-        let filter = PackageFilter::from_query(query);
+        let filters = query.create_filter();
 
-        let existing_install = get_existing_install(&core_db, &filter)?;
+        let options = QueryOptions {
+            limit: 1,
+            filters,
+            ..Default::default()
+        };
+
+        let installed_packages = get_installed_packages(core_db.clone(), options.clone())?.items;
+        let existing_install = if installed_packages.is_empty() {
+            None
+        } else {
+            Some(installed_packages.first().unwrap().clone())
+        };
 
         if let Some(ref existing) = existing_install {
             if existing.is_installed {
@@ -123,7 +135,7 @@ fn resolve_packages(
             }
         }
 
-        if let Some(package) = select_package(db.clone(), package, &filter, yes, &existing_install)?
+        if let Some(package) = select_package(db.clone(), package, options, yes, &existing_install)?
         {
             install_targets.push(InstallTarget {
                 package,
@@ -135,37 +147,29 @@ fn resolve_packages(
     Ok(install_targets)
 }
 
-fn get_existing_install(
-    core_db: &Arc<Mutex<Connection>>,
-    filter: &PackageFilter,
-) -> SoarResult<Option<InstalledPackage>> {
-    let installed_pkgs: Vec<InstalledPackage> =
-        get_installed_packages_with_filter(core_db.clone(), 128, filter.clone())?
-            .filter_map(Result::ok)
-            .collect();
-
-    Ok(installed_pkgs.into_iter().next())
-}
-
 fn select_package(
     db: Arc<Mutex<Connection>>,
     package_name: &str,
-    filter: &PackageFilter,
+    options: QueryOptions,
     yes: bool,
     existing_install: &Option<InstalledPackage>,
 ) -> SoarResult<Option<Package>> {
-    let filter = if let Some(existing) = existing_install {
-        PackageFilter {
-            repo_name: Some(existing.repo_name.clone()),
-            exact_pkg_name: Some(existing.pkg_name.clone()),
-            ..Default::default()
-        }
+    let options = if let Some(existing) = existing_install {
+        let mut filters = HashMap::new();
+        filters.insert(
+            "r.name".to_string(),
+            (FilterOp::Eq, existing.repo_name.clone().into()).into(),
+        );
+        filters.insert(
+            "pkg_name".to_string(),
+            (FilterOp::Eq, existing.pkg_name.clone().into()).into(),
+        );
+        QueryOptions { filters, ..options }
     } else {
-        filter.clone()
+        options
     };
-    let pkgs: Vec<Package> = get_packages_with_filter(db, 1024, filter)?
-        .filter_map(Result::ok)
-        .collect();
+
+    let pkgs = get_packages(db, options)?.items;
 
     match pkgs.len() {
         0 => {