perf(list): use minimal struct for listing packages

Author: QaidVoid

crates/soar-cli/src/install.rs

@@ -924,15 +924,29 @@ async fn spawn_installation_task(
     let permit = ctx.semaphore.clone().acquire_owned().await.unwrap();
     let progress_bar = Arc::new(Mutex::new(None));
 
+    // Pre-compute the prefix string to avoid cloning the entire Package struct
+    let prefix = {
+        let prefix = format!(
+            "[{}/{}] {}#{}",
+            idx + 1,
+            ctx.total_packages,
+            target.package.pkg_name,
+            target.package.pkg_id
+        );
+        if prefix.len() > fixed_width {
+            format!("{prefix:.fixed_width$}")
+        } else {
+            format!("{prefix:<fixed_width$}")
+        }
+    };
+
     let progress_callback = {
         let ctx = ctx.clone();
         let progress_bar = progress_bar.clone();
-        let package = target.package.clone();
 
         Arc::new(move |state| {
             let mut pb_lock = progress_bar.lock().unwrap();
-
-            handle_install_progress(state, &mut pb_lock, &ctx, &package, idx, fixed_width);
+            handle_install_progress(state, &mut pb_lock, &ctx, &prefix);
         })
     };
 

crates/soar-cli/src/list.rs

@@ -12,9 +12,12 @@ use soar_core::{
     package::query::PackageQuery,
     SoarResult,
 };
-use soar_db::repository::{
-    core::{CoreRepository, SortDirection},
-    metadata::MetadataRepository,
+use soar_db::{
+    models::metadata::PackageListing,
+    repository::{
+        core::{CoreRepository, SortDirection},
+        metadata::MetadataRepository,
+    },
 };
 use soar_utils::fs::dir_size;
 use tabled::{
@@ -367,31 +370,39 @@ pub async fn query_package(query_str: String) -> SoarResult<()> {
     Ok(())
 }
 
+/// Lightweight struct for listing with repo name attached
+struct PackageListingWithRepo {
+    repo_name: String,
+    pkg: PackageListing,
+}
+
 pub async fn list_packages(repo_name: Option<String>) -> SoarResult<()> {
     let state = AppState::new();
     let metadata_mgr = state.metadata_manager().await?;
     let diesel_db = state.diesel_core_db()?;
 
-    let packages: Vec<Package> = if let Some(ref repo_name) = repo_name {
+    let packages: Vec<PackageListingWithRepo> = if let Some(ref repo_name) = repo_name {
         metadata_mgr
-            .query_repo(repo_name, MetadataRepository::list_all)?
+            .query_repo(repo_name, MetadataRepository::list_all_minimal)?
             .unwrap_or_default()
             .into_iter()
-            .map(|p| {
-                let mut pkg: Package = p.into();
-                pkg.repo_name = repo_name.clone();
-                pkg
+            .map(|pkg| {
+                PackageListingWithRepo {
+                    repo_name: repo_name.clone(),
+                    pkg,
+                }
             })
             .collect()
     } else {
         metadata_mgr.query_all_flat(|repo_name, conn| {
-            let pkgs = MetadataRepository::list_all(conn)?;
+            let pkgs = MetadataRepository::list_all_minimal(conn)?;
             Ok(pkgs
                 .into_iter()
-                .map(|p| {
-                    let mut pkg: Package = p.into();
-                    pkg.repo_name = repo_name.to_string();
-                    pkg
+                .map(|pkg| {
+                    PackageListingWithRepo {
+                        repo_name: repo_name.to_string(),
+                        pkg,
+                    }
                 })
                 .collect())
         })?
@@ -409,11 +420,11 @@ pub async fn list_packages(repo_name: Option<String>) -> SoarResult<()> {
     let mut installed_count = 0;
     let mut available_count = 0;
 
-    for package in &packages {
+    for entry in &packages {
         let key = (
-            package.repo_name.clone(),
-            package.pkg_id.clone(),
-            package.pkg_name.clone(),
+            entry.repo_name.clone(),
+            entry.pkg.pkg_id.clone(),
+            entry.pkg.pkg_name.clone(),
         );
         let state_icon = match installed_pkgs.get(&key) {
             Some(is_installed) => {
@@ -431,25 +442,27 @@ pub async fn list_packages(repo_name: Option<String>) -> SoarResult<()> {
         };
 
         info!(
-            pkg_name = package.pkg_name,
-            pkg_id = package.pkg_id,
-            repo_name = package.repo_name,
-            pkg_type = package.pkg_type,
-            version = package.version,
-            version_upstream = package.version_upstream,
+            pkg_name = entry.pkg.pkg_name,
+            pkg_id = entry.pkg.pkg_id,
+            repo_name = entry.repo_name,
+            pkg_type = entry.pkg.pkg_type,
+            version = entry.pkg.version,
+            version_upstream = entry.pkg.version_upstream,
             "[{}] {}#{}:{} | {}{} | {}",
             state_icon,
-            Colored(Blue, &package.pkg_name),
-            Colored(Cyan, &package.pkg_id),
-            Colored(Cyan, &package.repo_name),
-            Colored(LightRed, &package.version),
-            package
+            Colored(Blue, &entry.pkg.pkg_name),
+            Colored(Cyan, &entry.pkg.pkg_id),
+            Colored(Cyan, &entry.repo_name),
+            Colored(LightRed, &entry.pkg.version),
+            entry
+                .pkg
                 .version_upstream
                 .as_ref()
-                .filter(|_| package.version.starts_with("HEAD"))
+                .filter(|_| entry.pkg.version.starts_with("HEAD"))
                 .map(|upstream| format!(":{}", Colored(Yellow, &upstream)))
                 .unwrap_or_default(),
-            package
+            entry
+                .pkg
                 .pkg_type
                 .as_ref()
                 .map(|pkg_type| format!("{}", Colored(Magenta, &pkg_type)))

crates/soar-cli/src/progress.rs

@@ -3,7 +3,6 @@ use std::sync::atomic::Ordering;
 use indicatif::{HumanBytes, ProgressBar, ProgressState, ProgressStyle};
 use nu_ansi_term::Color::Red;
 use soar_config::display::ProgressStyle as ConfigProgressStyle;
-use soar_core::database::models::Package;
 use soar_dl::types::Progress;
 
 use crate::{
@@ -110,29 +109,13 @@ pub fn handle_install_progress(
     state: Progress,
     progress_bar: &mut Option<ProgressBar>,
     ctx: &InstallContext,
-    package: &Package,
-    idx: usize,
-    fixed_width: usize,
+    prefix: &str,
 ) {
     if progress_bar.is_none() {
         let pb = ctx
             .multi_progress
             .insert_from_back(1, create_progress_bar());
-
-        let prefix = format!(
-            "[{}/{}] {}#{}",
-            idx + 1,
-            ctx.total_packages,
-            package.pkg_name,
-            package.pkg_id
-        );
-        let prefix = if prefix.len() > fixed_width {
-            format!("{prefix:.fixed_width$}")
-        } else {
-            format!("{prefix:<fixed_width$}")
-        };
-        pb.set_prefix(prefix);
-
+        pb.set_prefix(prefix.to_string());
         *progress_bar = Some(pb);
     }
 
@@ -183,15 +166,8 @@ pub fn handle_install_progress(
         Progress::Aborted => {
             let failed_count = ctx.failed.fetch_add(1, Ordering::Relaxed);
             if let Some(pb) = progress_bar {
-                let prefix = format!(
-                    "[{}/{}] {}#{}",
-                    idx + 1,
-                    ctx.total_packages,
-                    package.pkg_name,
-                    package.pkg_id
-                );
                 pb.set_style(ProgressStyle::with_template("{prefix} {msg}").unwrap());
-                pb.set_prefix(prefix);
+                pb.set_prefix(prefix.to_string());
                 pb.finish_with_message(format!(
                     "\n  {}",
                     Colored(Red, "└── Error: Too many failures. Aborted.")

crates/soar-db/src/models/metadata.rs

@@ -128,6 +128,19 @@ impl Queryable<packages::SqlType, Sqlite> for Package {
     }
 }
 
+/// Lightweight package struct for listing operations.
+/// Contains only the fields needed for display, reducing memory usage significantly.
+#[derive(Debug, Clone, Queryable, Selectable)]
+#[diesel(table_name = packages)]
+#[diesel(check_for_backend(diesel::sqlite::Sqlite))]
+pub struct PackageListing {
+    pub pkg_id: String,
+    pub pkg_name: String,
+    pub pkg_type: Option<String>,
+    pub version: String,
+    pub version_upstream: Option<String>,
+}
+
 /// Package with repository name attached.
 /// This is used when querying across multiple repositories.
 #[derive(Debug, Clone)]

crates/soar-db/src/repository/metadata.rs

@@ -15,6 +15,7 @@ use crate::{
     models::{
         metadata::{
             Maintainer, NewMaintainer, NewPackage, NewPackageMaintainer, NewRepository, Package,
+            PackageListing,
         },
         types::PackageProvide,
     },
@@ -40,6 +41,15 @@ impl MetadataRepository {
             .load(conn)
     }
 
+    /// Lists all packages with only the fields needed for display.
+    /// This is much more memory-efficient than list_all for large package lists.
+    pub fn list_all_minimal(conn: &mut SqliteConnection) -> QueryResult<Vec<PackageListing>> {
+        packages::table
+            .order(packages::pkg_name.asc())
+            .select(PackageListing::as_select())
+            .load(conn)
+    }
+
     /// Lists packages with pagination and sorting using Diesel DSL.
     pub fn list_paginated(
         conn: &mut SqliteConnection,