feat(labrinth): dependents api endpoint

Author: IThundxr

apps/labrinth/.sqlx/query-7c418e474c911332e6425bbb42775b14b5b9edbb23ede6da63d996973d06bf6c.json

@@ -19,6 +19,7 @@ use std::hash::Hash;
 pub const PROJECTS_NAMESPACE: &str = "projects";
 pub const PROJECTS_SLUGS_NAMESPACE: &str = "projects_slugs";
 const PROJECTS_DEPENDENCIES_NAMESPACE: &str = "projects_dependencies";
+const PROJECTS_DEPENDENTS_NAMESPACE: &str = "projects_dependents";
 
 #[derive(Clone, Debug, Serialize, Deserialize)]
 pub struct LinkUrl {
@@ -343,8 +344,14 @@ impl DBProject {
         let project = Self::get_id(id, &mut **transaction, redis).await?;
 
         if let Some(project) = project {
-            DBProject::clear_cache(id, project.inner.slug, Some(true), redis)
-                .await?;
+            DBProject::clear_cache(
+                id,
+                project.inner.slug,
+                Some(true),
+                Some(true),
+                redis,
+            )
+            .await?;
 
             sqlx::query!(
                 "
@@ -932,10 +939,60 @@ impl DBProject {
         Ok(dependencies)
     }
 
+    pub async fn get_dependents<'a, E>(
+        id: DBProjectId,
+        exec: E,
+        redis: &RedisPool,
+    ) -> Result<Vec<(DBVersionId, DBProjectId)>, DatabaseError>
+    where
+        E: sqlx::Executor<'a, Database = sqlx::Postgres>,
+    {
+        type Dependents = Vec<(DBVersionId, DBProjectId)>;
+
+        let mut redis = redis.connect().await?;
+
+        let dependents = redis
+            .get_deserialized_from_json::<Dependents>(
+                PROJECTS_DEPENDENTS_NAMESPACE,
+                &id.0.to_string(),
+            )
+            .await?;
+        if let Some(dependents) = dependents {
+            return Ok(dependents);
+        }
+
+        //             SELECT d.dependency_id, COALESCE(vd.mod_id, 0) mod_id, d.mod_dependency_id
+        let dependents: Dependents = sqlx::query!(
+            "
+            SELECT DISTINCT version.id version_id, mod.id FROM versions version
+                INNER JOIN mods mod ON version.mod_id = mod.id
+                INNER JOIN dependencies d ON version.id = d.dependent_id
+            WHERE mod.status = 'approved' AND d.mod_dependency_id = $1
+            ORDER BY mod.id;
+            ",
+            id as DBProjectId
+        )
+        .fetch(exec)
+        .map_ok(|x| (DBVersionId(x.version_id), DBProjectId(x.id)))
+        .try_collect::<Dependents>()
+        .await?;
+
+        redis
+            .set_serialized_to_json(
+                PROJECTS_DEPENDENTS_NAMESPACE,
+                id.0,
+                &dependents,
+                None,
+            )
+            .await?;
+        Ok(dependents)
+    }
+
     pub async fn clear_cache(
         id: DBProjectId,
         slug: Option<String>,
         clear_dependencies: Option<bool>,
+        clear_dependents: Option<bool>,
         redis: &RedisPool,
     ) -> Result<(), DatabaseError> {
         let mut redis = redis.connect().await?;
@@ -952,6 +1009,14 @@ impl DBProject {
                         None
                     },
                 ),
+                (
+                    PROJECTS_DEPENDENTS_NAMESPACE,
+                    if clear_dependents.unwrap_or(false) {
+                        Some(id.0.to_string())
+                    } else {
+                        None
+                    },
+                ),
             ])
             .await?;
         Ok(())

apps/labrinth/src/database/models/project_item.rs

@@ -451,6 +451,7 @@ impl DBVersion {
             DBProjectId(project_id.mod_id),
             None,
             None,
+            None,
             redis,
         )
         .await?;

apps/labrinth/src/database/models/version_item.rs

@@ -704,6 +704,7 @@ impl AutomatedModerationQueue {
                                         project.inner.id,
                                         project.inner.slug.clone(),
                                         None,
+                                        None,
                                         &redis,
                                     )
                                         .await?;

apps/labrinth/src/queue/moderation.rs

@@ -45,7 +45,8 @@ pub fn config(cfg: &mut web::ServiceConfig) {
                 web::scope("{project_id}")
                     .service(super::versions::version_list)
                     .service(super::versions::version_project_get)
-                    .service(dependency_list),
+                    .service(dependency_list)
+                    .service(dependents_list),
             ),
     );
 }
@@ -306,6 +307,52 @@ pub async fn dependency_list(
     }
 }
 
+#[get("dependents")]
+pub async fn dependents_list(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    // TODO: tests, probably
+    let response = v3::projects::dependents_list(
+        req,
+        info,
+        pool.clone(),
+        redis.clone(),
+        session_queue,
+    )
+    .await
+    .or_else(v2_reroute::flatten_404_error)?;
+
+    match v2_reroute::extract_ok_json::<
+        crate::routes::v3::projects::DependencyInfo,
+    >(response)
+    .await
+    {
+        Ok(dependency_info) => {
+            let converted_projects = LegacyProject::from_many(
+                dependency_info.projects,
+                &**pool,
+                &redis,
+            )
+            .await?;
+            let converted_versions = dependency_info
+                .versions
+                .into_iter()
+                .map(LegacyVersion::from)
+                .collect();
+
+            Ok(HttpResponse::Ok().json(DependencyInfo {
+                projects: converted_projects,
+                versions: converted_versions,
+            }))
+        }
+        Err(response) => Ok(response),
+    }
+}
+
 #[derive(Serialize, Deserialize, Validate)]
 pub struct EditProject {
     #[validate(

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

@@ -830,6 +830,7 @@ pub async fn organization_projects_add(
             project_item.inner.id,
             project_item.inner.slug,
             None,
+            None,
             &redis,
         )
         .await?;
@@ -1018,6 +1019,7 @@ pub async fn organization_projects_remove(
             project_item.inner.id,
             project_item.inner.slug,
             None,
+            None,
             &redis,
         )
         .await?;

apps/labrinth/src/routes/v3/organizations.rs

@@ -73,7 +73,8 @@ pub fn config(cfg: &mut web::ServiceConfig) {
                         "version/{slug}",
                         web::get().to(super::versions::version_project_get),
                     )
-                    .route("dependencies", web::get().to(dependency_list)),
+                    .route("dependencies", web::get().to(dependency_list))
+                    .route("dependents", web::get().to(dependents_list)),
             ),
     );
 }
@@ -895,6 +896,7 @@ pub async fn project_edit(
                 project_item.inner.id,
                 project_item.inner.slug,
                 None,
+                None,
                 &redis,
             )
             .await?;
@@ -1094,6 +1096,82 @@ pub async fn dependency_list(
     }
 }
 
+pub async fn dependents_list(
+    req: HttpRequest,
+    info: web::Path<(String,)>,
+    pool: web::Data<PgPool>,
+    redis: web::Data<RedisPool>,
+    session_queue: web::Data<AuthQueue>,
+) -> Result<HttpResponse, ApiError> {
+    let string = info.into_inner().0;
+
+    let result = db_models::DBProject::get(&string, &**pool, &redis).await?;
+
+    let user_option = get_user_from_headers(
+        &req,
+        &**pool,
+        &redis,
+        &session_queue,
+        Scopes::PROJECT_READ,
+    )
+    .await
+    .map(|x| x.1)
+    .ok();
+
+    if let Some(project) = result {
+        if !is_visible_project(&project.inner, &user_option, &pool, false)
+            .await?
+        {
+            return Err(ApiError::NotFound);
+        }
+
+        let dependents = database::DBProject::get_dependents(
+            project.inner.id,
+            &**pool,
+            &redis,
+        )
+        .await?;
+        let project_ids =
+            dependents.iter().map(|x| x.1).unique().collect::<Vec<_>>();
+
+        let dep_version_ids = dependents
+            .iter()
+            .map(|x| x.0)
+            .unique()
+            .collect::<Vec<db_models::DBVersionId>>();
+        let (projects_result, versions_result) = futures::future::try_join(
+            database::DBProject::get_many_ids(&project_ids, &**pool, &redis),
+            database::DBVersion::get_many(&dep_version_ids, &**pool, &redis),
+        )
+        .await?;
+
+        let mut projects = filter_visible_projects(
+            projects_result,
+            &user_option,
+            &pool,
+            false,
+        )
+        .await?;
+        let mut versions = filter_visible_versions(
+            versions_result,
+            &user_option,
+            &pool,
+            &redis,
+        )
+        .await?;
+
+        projects.sort_by(|a, b| b.published.cmp(&a.published));
+        projects.dedup_by(|a, b| a.id == b.id);
+
+        versions.sort_by(|a, b| b.date_published.cmp(&a.date_published));
+        versions.dedup_by(|a, b| a.id == b.id);
+
+        Ok(HttpResponse::Ok().json(DependencyInfo { projects, versions }))
+    } else {
+        Err(ApiError::NotFound)
+    }
+}
+
 pub struct CategoryChanges<'a> {
     pub categories: &'a Option<Vec<String>>,
     pub add_categories: &'a Option<Vec<String>>,
@@ -1328,6 +1406,7 @@ pub async fn projects_edit(
             project.inner.id,
             project.inner.slug,
             None,
+            None,
             &redis,
         )
         .await?;
@@ -1521,6 +1600,7 @@ pub async fn project_icon_edit(
         project_item.inner.id,
         project_item.inner.slug,
         None,
+        None,
         &redis,
     )
     .await?;
@@ -1610,6 +1690,7 @@ pub async fn delete_project_icon(
         project_item.inner.id,
         project_item.inner.slug,
         None,
+        None,
         &redis,
     )
     .await?;
@@ -1765,6 +1846,7 @@ pub async fn add_gallery_item(
         project_item.inner.id,
         project_item.inner.slug,
         None,
+        None,
         &redis,
     )
     .await?;
@@ -1948,6 +2030,7 @@ pub async fn edit_gallery_item(
         project_item.inner.id,
         project_item.inner.slug,
         None,
+        None,
         &redis,
     )
     .await?;
@@ -2062,6 +2145,7 @@ pub async fn delete_gallery_item(
         project_item.inner.id,
         project_item.inner.slug,
         None,
+        None,
         &redis,
     )
     .await?;

apps/labrinth/src/routes/v3/projects.rs

@@ -513,7 +513,14 @@ async fn version_create_inner(
         }
     }
 
-    models::DBProject::clear_cache(project_id, None, Some(true), redis).await?;
+    models::DBProject::clear_cache(
+        project_id,
+        None,
+        Some(true),
+        Some(true),
+        redis,
+    )
+    .await?;
 
     let project_status = sqlx::query!(
         "SELECT status FROM mods WHERE id = $1",