feat: use v1 version manifest for Quilt (#6650)

* wip: app-side logic

* lints

* fmt

* fmt

* Split Daedalus changes out of frontend branch

* Remove Daedalus changes from frontend branch

packages/app-lib/src/api/metadata.rs

@@ -22,8 +22,10 @@ pub async fn get_minecraft_versions() -> crate::Result<VersionManifest> {
 // #[tracing::instrument]
 pub async fn get_loader_versions(loader: &str) -> crate::Result<Manifest> {
     let state = State::get().await?;
+    let cache_key =
+        daedalus::modded::loader_manifest_metadata(loader).cache_key;
     let loaders = CachedEntry::get_loader_manifest(
-        loader,
+        &cache_key,
         None,
         &state.pool,
         &state.api_semaphore,

packages/app-lib/src/launcher/mod.rs

@@ -24,7 +24,7 @@ use crate::{State, get_resource_file, process};
 use chrono::Utc;
 use daedalus as d;
 use daedalus::minecraft::{LoggingSide, RuleAction, VersionInfo};
-use daedalus::modded::LoaderVersion;
+use daedalus::modded::{LoaderVersion, Manifest};
 use regex::Regex;
 use serde::Deserialize;
 use std::fmt::Write;
@@ -175,19 +175,18 @@ pub async fn get_loader_version_from_profile(
     let versions =
         crate::api::metadata::get_loader_versions(loader.as_meta_str()).await?;
 
-    let loaders = versions.game_versions.into_iter().find(|x| {
-        x.id.replace(daedalus::modded::DUMMY_REPLACE_STRING, game_version)
-            == game_version
-    });
-
-    if let Some(loaders) = loaders {
-        let loader_version = loaders.loaders.iter().find(|x| filter(x)).or(
-            if version == "stable" {
-                loaders.loaders.first()
-            } else {
-                None
-            },
-        );
+    if let Some(loaders) =
+        loader_versions_for_game_version(&versions, game_version)
+    {
+        let loader_version =
+            loaders
+                .iter()
+                .find(|x| filter(x))
+                .or(if version == "stable" {
+                    loaders.first()
+                } else {
+                    None
+                });
 
         Ok(loader_version.cloned())
     } else {
@@ -195,6 +194,26 @@ pub async fn get_loader_version_from_profile(
     }
 }
 
+fn loader_versions_for_game_version<'a>(
+    manifest: &'a Manifest,
+    game_version: &str,
+) -> Option<&'a [LoaderVersion]> {
+    let version = manifest.game_versions.iter().find(|x| {
+        x.id.replace(daedalus::modded::DUMMY_REPLACE_STRING, game_version)
+            == game_version
+    })?;
+
+    if let Some(version_group) = &version.version_group {
+        manifest
+            .version_groups
+            .iter()
+            .find(|group| group.id == *version_group)
+            .map(|group| group.loaders.as_slice())
+    } else {
+        Some(version.loaders.as_slice())
+    }
+}
+
 /// Resolves the Minecraft version manifest and finds the index for the given
 /// game version. If the version isn't found in the cache, forces a manifest
 /// refresh to pick up newly-released versions.

packages/app-lib/src/state/cache.rs

@@ -1396,19 +1396,25 @@ impl CachedEntry {
                 let fetch_urls = keys
                     .iter()
                     .map(|x| {
+                        let metadata =
+                            daedalus::modded::loader_manifest_metadata_from_cache_key(
+                                &x.key().to_string(),
+                            );
+
                         (
-                            x.key().to_string(),
+                            metadata.cache_key,
+                            metadata.loader,
                             format!(
-                                "{}{}/v0/manifest.json",
+                                "{}{}",
                                 env!("MODRINTH_LAUNCHER_META_URL"),
-                                x.key()
+                                metadata.path,
                             ),
                         )
                     })
                     .collect::<Vec<_>>();
 
                 futures::future::try_join_all(fetch_urls.iter().map(
-                    |(_, url)| {
+                    |(_, _, url)| {
                         fetch_json(
                             Method::GET,
                             url,
@@ -1424,14 +1430,15 @@ impl CachedEntry {
                 .into_iter()
                 .enumerate()
                 .map(|(index, metadata)| {
-                    (
+                    let mut entry =
                         CacheValue::LoaderManifest(CachedLoaderManifest {
-                            loader: fetch_urls[index].0.to_string(),
+                            loader: fetch_urls[index].1.to_string(),
                             manifest: metadata,
                         })
-                        .get_entry(),
-                        true,
-                    )
+                        .get_entry();
+                    entry.id.clone_from(&fetch_urls[index].0);
+
+                    (entry, true)
                 })
                 .collect()
             }