Move version compatibility info to backend version list route

apps/frontend/src/pages/[type]/[id].vue

@@ -1059,15 +1059,11 @@ const currentGameVersion = computed(() => {
 })
 
 const possibleGameVersions = computed(() => {
-	return versions.value
-		.filter((x) => !currentPlatform.value || x.loaders.includes(currentPlatform.value))
-		.flatMap((x) => x.game_versions)
+	return versionsV3.value?.available_game_versions || []
 })
 
 const possiblePlatforms = computed(() => {
-	return versions.value
-		.filter((x) => !currentGameVersion.value || x.game_versions.includes(currentGameVersion.value))
-		.flatMap((x) => x.loaders)
+	return versionsV3.value?.available_loaders || []
 })
 
 const currentPlatform = computed(() => {
@@ -1414,29 +1410,11 @@ const filteredVersions = computed(() => {
 	)
 })
 
-const filteredRelease = computed(() => {
-	return filteredVersions.value.find((x) => x.version_type === 'release')
-})
+const filteredRelease = computed(() => versionsV3.value?.latest_versions?.release || null)
 
-const filteredBeta = computed(() => {
-	return filteredVersions.value.find(
-		(x) =>
-			x.version_type === 'beta' &&
-			(!filteredRelease.value ||
-				dayjs(x.date_published).isAfter(dayjs(filteredRelease.value.date_published))),
-	)
-})
+const filteredBeta = computed(() => versionsV3.value?.latest_versions?.beta || null)
 
-const filteredAlpha = computed(() => {
-	return filteredVersions.value.find(
-		(x) =>
-			x.version_type === 'alpha' &&
-			(!filteredRelease.value ||
-				dayjs(x.date_published).isAfter(dayjs(filteredRelease.value.date_published))) &&
-			(!filteredBeta.value ||
-				dayjs(x.date_published).isAfter(dayjs(filteredBeta.value.date_published))),
-	)
-})
+const filteredAlpha = computed(() => versionsV3.value?.latest_versions?.alpha || null)
 
 const displayCollectionsSearch = ref('')
 const collections = computed(() =>
@@ -1472,14 +1450,12 @@ let project,
 	dependencies,
 	versions,
 	versionsV3,
-	resetVersionsV2,
 	organization,
 	resetOrganization,
 	projectV2Error,
 	projectV3Error,
 	membersError,
 	dependenciesError,
-	versionsError,
 	versionsV3Error,
 	resetVersionsV3
 try {
@@ -1488,7 +1464,6 @@ try {
 		{ data: projectV3, error: projectV3Error, refresh: resetProjectV3 },
 		{ data: allMembers, error: membersError, refresh: resetMembers },
 		{ data: dependencies, error: dependenciesError },
-		{ data: versions, error: versionsError, refresh: resetVersionsV2 },
 		{ data: versionsV3, error: versionsV3Error, refresh: resetVersionsV3 },
 		{ data: organization, refresh: resetOrganization },
 	] = await Promise.all([
@@ -1528,9 +1503,6 @@ try {
 		useAsyncData(`project/${projectId.value}/dependencies`, () =>
 			useBaseFetch(`project/${projectId.value}/dependencies`, {}),
 		),
-		useAsyncData(`project/${projectId.value}/version`, () =>
-			useBaseFetch(`project/${projectId.value}/version`),
-		),
 		useAsyncData(`project/${projectId.value}/version/v3`, () =>
 			useBaseFetch(`project/${projectId.value}/version`, { apiVersion: 3 }),
 		),
@@ -1541,12 +1513,8 @@ try {
 
 	await updateProjectRoute()
 
-	versions = shallowRef(toRaw(versions))
-	versionsV3 = shallowRef(toRaw(versionsV3))
-	versions.value = (versions.value ?? []).map((v) => ({
-		...v,
-		environment: versionsV3.value?.find((v3) => v3.id === v.id)?.environment,
-	}))
+	versions = shallowRef(toRaw(versionsV3.value?.versions))
+	versionsV3 = shallowRef(toRaw(versionsV3.value))
 } catch (err) {
 	throw createError({
 		fatal: true,
@@ -1584,13 +1552,9 @@ async function resetProject() {
 }
 
 async function resetVersions() {
-	await resetVersionsV2()
 	await resetVersionsV3()
 
-	versions.value = (versions.value ?? []).map((v) => ({
-		...v,
-		environment: versionsV3.value?.find((v3) => v3.id === v.id)?.environment,
-	}))
+	versions.value = versionsV3.value?.versions || []
 }
 
 function handleError(err, project = false) {
@@ -1610,7 +1574,6 @@ handleError(projectV2Error, true)
 handleError(projectV3Error)
 handleError(membersError)
 handleError(dependenciesError)
-handleError(versionsError)
 handleError(versionsV3Error)
 
 if (!project.value) {

apps/labrinth/src/routes/internal/delphi.rs

@@ -327,7 +327,7 @@ pub async fn run(
         .send()
         .await
         .and_then(|res| res.error_for_status())
-        .map_err(ApiError::Delphi)?;
+        .map_err(ApiError::delphi)?;
 
     Ok(HttpResponse::NoContent().finish())
 }
@@ -411,10 +411,10 @@ async fn issue_type_schema(
                         .send()
                         .await
                         .and_then(|res| res.error_for_status())
-                        .map_err(ApiError::Delphi)?
+                        .map_err(ApiError::delphi)?
                         .json::<serde_json::Map<String, serde_json::Value>>()
                         .await
-                        .map_err(ApiError::Delphi)?,
+                        .map_err(ApiError::delphi)?,
                     Instant::now(),
                 ))
                 .0,

apps/labrinth/src/routes/mod.rs

@@ -163,8 +163,8 @@ pub enum ApiError {
     RateLimitError(u128, u32),
     #[error("Error while interacting with payment processor: {0}")]
     Stripe(#[from] stripe::StripeError),
-    #[error("Error while interacting with Delphi: {0}")]
-    Delphi(reqwest::Error),
+    #[error("Error while interacting with Delphi: {0:?}")]
+    Delphi(eyre::Error),
     #[error(transparent)]
     Mural(#[from] Box<muralpay::ApiError>),
     #[error("report still has {} issue details with no verdict", details.len())]
@@ -174,6 +174,10 @@ pub enum ApiError {
 }
 
 impl ApiError {
+    pub fn delphi(err: impl Into<eyre::Error>) -> Self {
+        Self::Delphi(err.into())
+    }
+
     pub fn as_api_error<'a>(&self) -> crate::models::error::ApiError<'a> {
         crate::models::error::ApiError {
             error: match self {

apps/labrinth/src/routes/v2/versions.rs

@@ -94,10 +94,10 @@ pub async fn version_list(
         featured: filters.featured,
         version_type: filters.version_type,
         limit: filters.limit,
-        offset: filters.offset,
+        ..Default::default()
     };
 
-    let response = v3::versions::version_list(
+    let response = match v3::versions::version_list(
         req,
         info,
         web::Query(filters),
@@ -106,19 +106,20 @@ pub async fn version_list(
         session_queue,
     )
     .await
-    .or_else(v2_reroute::flatten_404_error)?;
+    {
+        Ok(r) => r,
+        Err(ApiError::NotFound) => return Ok(HttpResponse::NotFound().body("")),
+        Err(e) => return Err(e),
+    };
 
     // Convert response to V2 format
-    match v2_reroute::extract_ok_json::<Vec<Version>>(response).await {
-        Ok(versions) => {
-            let v2_versions = versions
-                .into_iter()
-                .map(LegacyVersion::from)
-                .collect::<Vec<_>>();
-            Ok(HttpResponse::Ok().json(v2_versions))
-        }
-        Err(response) => Ok(response),
-    }
+    let v2_versions = response
+        .0
+        .versions
+        .into_iter()
+        .map(LegacyVersion::from)
+        .collect::<Vec<_>>();
+    Ok(HttpResponse::Ok().json(v2_versions))
 }
 
 // Given a project ID/slug and a version slug