Refactors CAS manifest handling for loaders

Author: blarfoon

daedalus/src/lib.rs

@@ -187,12 +187,10 @@ impl GradleSpecifier {
 
     /// Returns if specifier belongs to a lwjgl library
     pub fn is_lwjgl(&self) -> bool {
-        vec![
-            "org.lwjgl",
+        ["org.lwjgl",
             "org.lwjgl.lwjgl",
             "net.java.jinput",
-            "net.java.jutils",
-        ]
+            "net.java.jutils"]
         .contains(&self.package.as_str())
     }
 
@@ -379,7 +377,7 @@ pub async fn download_file_mirrors(
         }
     }
 
-    return Err(Error::MirrorsFailed("No mirrors succeeded!".to_string()));
+    Err(Error::MirrorsFailed("No mirrors succeeded!".to_string()))
 }
 
 /// Downloads a file with retry and checksum functionality

daedalus/src/version.rs

@@ -20,17 +20,25 @@ pub enum MinecraftVersion {
     /// Snapshot version (YYwWWx format)
     /// Example: 23w10a = year 23, week 10, revision a
     Snapshot {
+        /// Year (e.g., 23 for 2023)
         year: u32,
+        /// Week number (1-52)
         week: u32,
+        /// Revision letter (e.g., "a", "b")
         revision: String,
     },
     /// Regular release version
     /// Example: 1.20.4
     Release {
+        /// Major version number
         major: u32,
+        /// Minor version number
         minor: u32,
+        /// Patch version number
         patch: u32,
+        /// Pre-release identifier (pre, rc, etc.)
         prerelease: Option<Prerelease>,
+        /// Build metadata (for Forge versions)
         build: Option<Vec<u32>>,
     },
 }

daedalus_client/src/forge.rs

@@ -411,13 +411,6 @@ pub async fn retrieve_data(
                                         new_hash.clone()
                                     };
 
-                                    manifest_builder.add_version(
-                                        "forge",
-                                        loader_version_full.to_string(),
-                                        version_hash.clone(),
-                                        version_bytes.len() as u64,
-                                    );
-
                                     let base_url = dotenvy::var("BASE_URL").unwrap();
                                     let cas_url = format!(
                                         "{}/v{}/objects/{}/{}",
@@ -745,13 +738,6 @@ pub async fn retrieve_data(
                                         new_hash.clone()
                                     };
 
-                                    manifest_builder.add_version(
-                                        "forge",
-                                        loader_version_full.to_string(),
-                                        version_hash.clone(),
-                                        version_bytes.len() as u64,
-                                    );
-
                                     let base_url = dotenvy::var("BASE_URL").unwrap();
                                     let cas_url = format!(
                                         "{}/v{}/objects/{}/{}",
@@ -930,6 +916,12 @@ pub async fn retrieve_data(
                 })
             }
         }
+
+        // Set the full Forge versions JSON in manifest_builder with nested structure
+        // This preserves game version -> loader version mappings
+        let versions_json = serde_json::to_value(&final_versions)?;
+        manifest_builder.set_loader_versions("forge", versions_json);
+        info!(version_count = final_versions.len(), "Set Forge versions with nested structure in CAS manifest builder");
     }
 
     Ok(())

daedalus_client/src/loaders/mod.rs

@@ -557,6 +557,7 @@ impl<S: LoaderStrategy> LoaderProcessor<S> {
             loader.clone(),
             version_hash.clone(),
             version_bytes.len() as u64,
+            version_info.release_time,
         );
 
         let base_url = dotenvy::var("BASE_URL").unwrap();

daedalus_client/src/main.rs

@@ -382,7 +382,7 @@ fn main() -> Result<(), crate::infrastructure::error::Error> {
 
                                 info!(
                                     loader = %loader,
-                                    version_count = loader_manifest.versions.len(),
+                                    version_count = loader_manifest.versions.as_array().map(|a| a.len()).unwrap_or(0),
                                     path = %manifest_path,
                                     "Uploading loader manifest"
                                 );

daedalus_client/src/minecraft.rs

@@ -641,9 +641,7 @@ pub async fn retrieve_data(
                                         .expect("Safe to unwrap since we ensure it's valid in version_json already")
                                 }),
                                 compliance_level: 1,
-                                assets_index_url: Some(
-                                    version_info.asset_index.sha1.clone(),
-                                ),
+                                assets_index_url: Some(format_url(&assets_path)),
                                 assets_index_sha1: Some(
                                     version_info.asset_index.sha1.clone(),
                                 ),
@@ -691,19 +689,16 @@ pub async fn retrieve_data(
                 }
 
                 let version_bytes = serde_json::to_vec(&version_info)?;
-                let version_hash = uploader.upload_cas(
+                let _version_hash = uploader.upload_cas(
                     version_bytes.clone(),
                     Some("application/json".to_string()),
                     s3_client,
                     semaphore.clone(),
                 ).await?;
 
-                manifest_builder.add_version(
-                    "minecraft",
-                    version_info.id.clone(),
-                    version_hash,
-                    version_bytes.len() as u64,
-                );
+                // NOTE: We don't call manifest_builder.add_version() for minecraft here.
+                // Instead, we use set_loader_versions() with the full VersionManifest at the end
+                // to preserve rich metadata (type, url, time, releaseTime, sha1, etc.)
 
                 Ok::<(), crate::infrastructure::error::Error>(())
             }
@@ -861,6 +856,7 @@ pub async fn retrieve_data(
                             lwjgl.version.clone(),
                             lwjgl_hash,
                             lwjgl_bytes.len() as u64,
+                            lwjgl.release_time,
                         );
 
                     } else {
@@ -887,13 +883,22 @@ pub async fn retrieve_data(
     let elapsed = now.elapsed();
     info!("Elapsed: {:.2?}", elapsed);
 
-    Ok(Arc::try_unwrap(cloned_manifest)
+    // Get the final manifest with all processed versions
+    let final_manifest = Arc::try_unwrap(cloned_manifest)
         .map_err(|err| {
             crate::infrastructure::error::invalid_input(
                 format!("Failed to unwrap Arc<Mutex<VersionManifest>>: {:?}", err)
             )
         })?
-        .into_inner())
+        .into_inner();
+
+    // Set the full Minecraft versions JSON in manifest_builder
+    // This preserves rich metadata (type, url, time, releaseTime, sha1, complianceLevel, etc.)
+    let versions_json = serde_json::to_value(&final_manifest.versions)?;
+    manifest_builder.set_loader_versions("minecraft", versions_json);
+    info!(version_count = final_manifest.versions.len(), "Set Minecraft versions with rich metadata in CAS manifest builder");
+
+    Ok(final_manifest)
 }
 
 #[derive(Deserialize, Debug, Clone)]

daedalus_client/src/neoforge.rs

@@ -368,13 +368,6 @@ pub async fn retrieve_data(
                                     new_hash.clone()
                                 };
 
-                                manifest_builder.add_version(
-                                    "neoforge",
-                                    loader_version_full.to_string(),
-                                    version_hash.clone(),
-                                    version_bytes.len() as u64,
-                                );
-
                                 let base_url = dotenvy::var("BASE_URL").unwrap();
                                 let cas_url = format!(
                                     "{}/v{}/objects/{}/{}",
@@ -558,13 +551,11 @@ pub async fn retrieve_data(
             }
         }
 
-        // Note: Versions are now tracked in ManifestBuilder and uploaded separately
-        // in the main loop via manifest_builder.build_loader_manifest()
-
-        info!(
-            "✅ NeoForge - Processed {} Minecraft versions",
-            final_versions.len()
-        );
+        // Set the full NeoForge versions JSON in manifest_builder with nested structure
+        // This preserves game version -> loader version mappings
+        let versions_json = serde_json::to_value(&final_versions)?;
+        manifest_builder.set_loader_versions("neoforge", versions_json);
+        info!(version_count = final_versions.len(), "Set NeoForge versions with nested structure in CAS manifest builder");
     }
 
     Ok(())