feat(crate): init soar-registry crate (#119)

Author: QaidVoid

Cargo.lock

@@ -4,6 +4,7 @@ members = [
   "crates/soar-config",
   "crates/soar-db",
   "crates/soar-dl",
+  "crates/soar-registry",
   "crates/soar-utils",
   "soar-cli",
   "soar-core"
@@ -43,6 +44,7 @@ serial_test = "3.2.0"
 soar-config = { path = "crates/soar-config" }
 soar-core = { path = "soar-core" }
 soar-dl = { path = "crates/soar-dl" }
+soar-registry = { path = "crates/soar-registry" }
 soar-utils = { path = "crates/soar-utils" }
 tempfile = "3.10.1"
 thiserror = "2.0.17"
@@ -52,6 +54,7 @@ tracing = { version = "0.1.41", default-features = false }
 ureq = { version = "3.1.2", features = ["json"] }
 url = "2.5.7"
 xattr = "1.6.1"
+zstd = "0.13.3"
 
 [profile.release]
 opt-level = 3

Cargo.toml

@@ -13,22 +13,25 @@ pub enum DbType {
     Nest,
 }
 
+fn get_migrations(db_type: &DbType) -> EmbeddedMigrations {
+    match db_type {
+        DbType::Core => CORE_MIGRATIONS,
+        DbType::Metadata => METADATA_MIGRATIONS,
+        DbType::Nest => NEST_MIGRATIONS,
+    }
+}
+
 pub fn apply_migrations(
     conn: &mut SqliteConnection,
     db_type: DbType,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
     loop {
-        let source = match db_type {
-            DbType::Core => CORE_MIGRATIONS,
-            DbType::Metadata => METADATA_MIGRATIONS,
-            DbType::Nest => NEST_MIGRATIONS,
-        };
-        match conn.run_pending_migrations(source) {
+        match conn.run_pending_migrations(get_migrations(&db_type)) {
             Ok(_) => break,
             Err(e) if e.to_string().contains("already exists") => {
-                mark_first_pending(conn)?;
+                mark_first_pending(conn, &db_type)?;
             }
-            Err(e) => return Err(e.into()),
+            Err(e) => return Err(e),
         }
     }
 
@@ -37,8 +40,9 @@ pub fn apply_migrations(
 
 fn mark_first_pending(
     conn: &mut SqliteConnection,
+    db_type: &DbType,
 ) -> Result<(), Box<dyn Error + Send + Sync + 'static>> {
-    let pending = conn.pending_migrations(CORE_MIGRATIONS)?;
+    let pending = conn.pending_migrations(get_migrations(db_type))?;
     if let Some(first) = pending.first() {
         sql_query("INSERT INTO __diesel_schema_migrations (version) VALUES (?1)")
             .bind::<diesel::sql_types::Text, _>(first.name().version())

crates/soar-db/src/migration.rs

@@ -0,0 +1,24 @@
+[package]
+name = "soar-registry"
+version = "0.1.0"
+description = "Registry management for soar package manager"
+authors.workspace = true
+edition.workspace = true
+readme.workspace = true
+repository.workspace = true
+license.workspace = true
+keywords.workspace = true
+categories.workspace = true
+
+[dependencies]
+miette = { workspace = true }
+serde = { workspace = true }
+serde_json = { workspace = true }
+soar-config = { workspace = true }
+soar-dl = { workspace = true }
+soar-utils = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }
+ureq = { workspace = true }
+url = { workspace = true }
+zstd = { workspace = true }

crates/soar-registry/Cargo.toml

@@ -0,0 +1,124 @@
+//! Error types for the registry crate.
+//!
+//! This module defines [`RegistryError`], the error type used throughout
+//! the crate, along with helper traits for error context.
+
+use miette::Diagnostic;
+use thiserror::Error;
+
+/// Errors that can occur during registry operations.
+///
+/// This enum covers all error conditions that can arise when fetching,
+/// processing, or storing package metadata.
+#[derive(Error, Diagnostic, Debug)]
+pub enum RegistryError {
+    #[error("IO error while {action}: {source}")]
+    #[diagnostic(code(soar_registry::io))]
+    IoError {
+        action: String,
+        source: std::io::Error,
+    },
+
+    #[error("System time error: {0}")]
+    #[diagnostic(code(soar_registry::system_time))]
+    SystemTimeError(#[from] std::time::SystemTimeError),
+
+    #[error("HTTP request error: {0:?}")]
+    #[diagnostic(
+        code(soar_registry::http),
+        help("Check your network connection and the repository URL")
+    )]
+    UreqError(#[from] ureq::Error),
+
+    #[error("Download failed: {0}")]
+    #[diagnostic(code(soar_registry::download))]
+    DownloadError(#[from] soar_dl::error::DownloadError),
+
+    #[error("Failed to fetch from remote source: {0}")]
+    #[diagnostic(
+        code(soar_registry::fetch_remote),
+        help("Verify the repository URL is correct and accessible")
+    )]
+    FailedToFetchRemote(String),
+
+    #[error("JSON parse error: {0}")]
+    #[diagnostic(
+        code(soar_registry::json),
+        help("The metadata file may be corrupted or in an invalid format")
+    )]
+    JsonError(#[from] serde_json::Error),
+
+    #[error("Invalid URL: {0}")]
+    #[diagnostic(
+        code(soar_registry::invalid_url),
+        help("Ensure the URL is valid and properly formatted")
+    )]
+    InvalidUrl(String),
+
+    #[error("Metadata content is too short")]
+    #[diagnostic(
+        code(soar_registry::metadata_too_short),
+        help("The metadata file appears to be corrupted or incomplete")
+    )]
+    MetadataTooShort,
+
+    #[error("ETag not found in metadata response")]
+    #[diagnostic(
+        code(soar_registry::missing_etag),
+        help("The server did not return an ETag header")
+    )]
+    MissingEtag,
+
+    #[error("{0}")]
+    #[diagnostic(code(soar_registry::custom))]
+    Custom(String),
+}
+
+/// A specialized Result type for registry operations.
+pub type Result<T> = std::result::Result<T, RegistryError>;
+
+/// Extension trait for adding context to I/O errors.
+///
+/// This trait provides a convenient way to convert `std::io::Result` into
+/// [`Result`] with descriptive context about what operation failed.
+pub trait ErrorContext<T> {
+    /// Adds context to an error, describing what action was being performed.
+    ///
+    /// # Arguments
+    ///
+    /// * `context` - A closure that returns a description of the failed action
+    fn with_context<C>(self, context: C) -> Result<T>
+    where
+        C: FnOnce() -> String;
+}
+
+impl<T> ErrorContext<T> for std::io::Result<T> {
+    fn with_context<C>(self, context: C) -> Result<T>
+    where
+        C: FnOnce() -> String,
+    {
+        self.map_err(|err| {
+            RegistryError::IoError {
+                action: context(),
+                source: err,
+            }
+        })
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_error_display() {
+        let err = RegistryError::MetadataTooShort;
+        assert_eq!(err.to_string(), "Metadata content is too short");
+
+        let err = RegistryError::MissingEtag;
+        assert_eq!(err.to_string(), "ETag not found in metadata response");
+
+        let err = RegistryError::InvalidUrl("bad-url".to_string());
+        assert_eq!(err.to_string(), "Invalid URL: bad-url");
+    }
+}

crates/soar-registry/src/error.rs

@@ -0,0 +1,48 @@
+//! Registry management for the soar package manager.
+//!
+//! This crate provides functionality for fetching, processing, and managing
+//! package metadata from remote repositories and nests.
+//!
+//! # Overview
+//!
+//! The crate handles two main types of metadata sources:
+//! - **Repositories**: Standard package repositories containing package metadata
+//! - **Nests**: User-defined package collections (similar to PPAs or custom repos)
+//!
+//! Metadata can be provided in two formats:
+//! - SQLite databases (`.sdb` files, optionally zstd-compressed)
+//! - JSON files containing package arrays
+//!
+//! # Example
+//!
+//! ```no_run
+//! use soar_registry::{fetch_metadata, MetadataContent};
+//! use soar_config::repository::Repository;
+//!
+//! async fn sync_repo(repo: &Repository) -> soar_registry::Result<()> {
+//!     if let Some((etag, content)) = fetch_metadata(repo, false).await? {
+//!         match content {
+//!             MetadataContent::SqliteDb(bytes) => {
+//!                 // Write SQLite database to disk
+//!             }
+//!             MetadataContent::Json(packages) => {
+//!                 // Process JSON packages into a database
+//!             }
+//!         }
+//!     }
+//!     Ok(())
+//! }
+//! ```
+
+pub mod error;
+pub mod metadata;
+pub mod nest;
+pub mod package;
+
+pub use error::{ErrorContext, RegistryError, Result};
+pub use metadata::{
+    fetch_metadata, fetch_nest_metadata, fetch_public_key, process_metadata_content,
+    write_metadata_db, MetadataContent, SQLITE_MAGIC_BYTES, ZST_MAGIC_BYTES,
+};
+pub use nest::Nest;
+pub use package::RemotePackage;