Use either instead of manually implemented enums (fixes #5513)

Author: Nutomic

Diff for: Cargo.lock

@@ -37,14 +37,14 @@ itertools = { workspace = true }
 uuid = { workspace = true }
 async-trait = "0.1.86"
 anyhow = { workspace = true }
-reqwest = { workspace = true }
 moka.workspace = true
 serde_with.workspace = true
 html2md = "0.2.15"
 html2text = "0.14.0"
 stringreader = "0.1.1"
 enum_delegate = "0.2.0"
 semver = "1.0.25"
+either = "1.15.0"
 
 [dev-dependencies]
 serial_test = { workspace = true }

Diff for: crates/apub/Cargo.toml

@@ -1,7 +1,7 @@
 use crate::{
   activities::send_lemmy_activity,
   activity_lists::AnnouncableActivities,
-  fetcher::post_or_comment::PostOrComment,
+  fetcher::PostOrComment,
   objects::{community::ApubCommunity, instance::ApubSite, person::ApubPerson},
   protocol::activities::community::announce::AnnounceActivity,
 };
@@ -96,8 +96,8 @@ async fn report_inboxes(
 
     // also send report to user's home instance if possible
     let object_creator_id = match object_id.dereference_local(context).await? {
-      PostOrComment::Post(p) => p.creator_id,
-      PostOrComment::Comment(c) => c.creator_id,
+      PostOrComment::Left(p) => p.creator_id,
+      PostOrComment::Right(c) => c.creator_id,
     };
     let object_creator = Person::read(&mut context.pool(), object_creator_id).await?;
     let object_creator_site: Option<ApubSite> =

Diff for: crates/apub/src/activities/community/mod.rs

@@ -95,7 +95,7 @@ impl ActivityHandler for Report {
     let actor = self.actor.dereference(context).await?;
     let reason = self.reason()?;
     match self.object.dereference(context).await? {
-      PostOrComment::Post(post) => {
+      PostOrComment::Left(post) => {
         check_post_deleted_or_removed(&post)?;
 
         let report_form = PostReportForm {
@@ -109,7 +109,7 @@ impl ActivityHandler for Report {
         };
         PostReport::report(&mut context.pool(), &report_form).await?;
       }
-      PostOrComment::Comment(comment) => {
+      PostOrComment::Right(comment) => {
         check_comment_deleted_or_removed(&comment)?;
 
         let report_form = CommentReportForm {

Diff for: crates/apub/src/activities/community/report.rs

@@ -87,10 +87,10 @@ impl ActivityHandler for ResolveReport {
     let reporter = self.object.actor.dereference(context).await?;
     let actor = self.actor.dereference(context).await?;
     match self.object.object.dereference(context).await? {
-      PostOrComment::Post(post) => {
+      PostOrComment::Left(post) => {
         PostReport::resolve_apub(&mut context.pool(), post.id, reporter.id, actor.id).await?;
       }
-      PostOrComment::Comment(comment) => {
+      PostOrComment::Right(comment) => {
         CommentReport::resolve_apub(&mut context.pool(), comment.id, reporter.id, actor.id).await?;
       }
     };

Diff for: crates/apub/src/activities/community/resolve_report.rs

@@ -1,5 +1,6 @@
+use super::send_activity_from_user_or_community;
 use crate::{
-  activities::{generate_activity_id, send_lemmy_activity},
+  activities::generate_activity_id,
   insert_received_activity,
   protocol::activities::following::{accept::AcceptFollow, follow::Follow},
 };
@@ -32,7 +33,7 @@ impl AcceptFollow {
       )?,
     };
     let inbox = ActivitySendTargets::to_inbox(person.shared_inbox_or_inbox());
-    send_lemmy_activity(context, accept, &user_or_community, inbox, true).await
+    send_activity_from_user_or_community(context, accept, user_or_community, inbox).await
   }
 }
 

Diff for: crates/apub/src/activities/following/accept.rs

@@ -5,7 +5,7 @@ use crate::{
     verify_person,
     verify_person_in_community,
   },
-  fetcher::user_or_community::UserOrCommunity,
+  fetcher::UserOrCommunity,
   insert_received_activity,
   objects::{community::ApubCommunity, person::ApubPerson},
   protocol::activities::following::{accept::AcceptFollow, follow::Follow},
@@ -79,7 +79,7 @@ impl ActivityHandler for Follow {
   async fn verify(&self, context: &Data<LemmyContext>) -> LemmyResult<()> {
     verify_person(&self.actor, context).await?;
     let object = self.object.dereference(context).await?;
-    if let UserOrCommunity::Community(c) = object {
+    if let UserOrCommunity::Right(c) = object {
       verify_person_in_community(&self.actor, &c, context).await?;
     }
     if let Some(to) = &self.to {
@@ -94,12 +94,12 @@ impl ActivityHandler for Follow {
     let actor = self.actor.dereference(context).await?;
     let object = self.object.dereference(context).await?;
     match object {
-      UserOrCommunity::User(u) => {
+      UserOrCommunity::Left(u) => {
         let form = PersonFollowerForm::new(u.id, actor.id, false);
         PersonActions::follow(&mut context.pool(), &form).await?;
         AcceptFollow::send(self, context).await?;
       }
-      UserOrCommunity::Community(c) => {
+      UserOrCommunity::Right(c) => {
         if c.visibility == CommunityVisibility::Private {
           let instance = Instance::read(&mut context.pool(), actor.instance_id).await?;
           if [Some("kbin"), Some("mbin")].contains(&instance.software.as_deref()) {

Diff for: crates/apub/src/activities/following/follow.rs

@@ -1,5 +1,6 @@
-use super::generate_activity_id;
+use super::{generate_activity_id, send_lemmy_activity};
 use crate::{
+  fetcher::UserOrCommunity,
   objects::{community::ApubCommunity, person::ApubPerson},
   protocol::activities::following::{
     accept::AcceptFollow,
@@ -8,14 +9,15 @@ use crate::{
     undo_follow::UndoFollow,
   },
 };
-use activitypub_federation::{config::Data, kinds::activity::FollowType};
+use activitypub_federation::{config::Data, kinds::activity::FollowType, traits::ActivityHandler};
 use lemmy_api_common::context::LemmyContext;
 use lemmy_db_schema::{
   newtypes::{CommunityId, PersonId},
-  source::{community::Community, person::Person},
+  source::{activity::ActivitySendTargets, community::Community, person::Person},
   traits::Crud,
 };
-use lemmy_utils::error::LemmyResult;
+use lemmy_utils::error::{LemmyError, LemmyResult};
+use serde::Serialize;
 
 pub(crate) mod accept;
 pub(crate) mod follow;
@@ -62,3 +64,23 @@ pub async fn send_accept_or_reject_follow(
     RejectFollow::send(follow, context).await
   }
 }
+
+/// Wrapper type which is needed because we cant implement ActorT for Either.
+async fn send_activity_from_user_or_community<Activity>(
+  context: &Data<LemmyContext>,
+  activity: Activity,
+  user_or_community: UserOrCommunity,
+  send_targets: ActivitySendTargets,
+) -> LemmyResult<()>
+where
+  Activity: ActivityHandler + Serialize + Send + Sync + Clone + ActivityHandler<Error = LemmyError>,
+{
+  match user_or_community {
+    UserOrCommunity::Left(user) => {
+      send_lemmy_activity(context, activity, &user, send_targets, true).await
+    }
+    UserOrCommunity::Right(community) => {
+      send_lemmy_activity(context, activity, &community, send_targets, true).await
+    }
+  }
+}

Diff for: crates/apub/src/activities/following/mod.rs

@@ -1,5 +1,6 @@
+use super::send_activity_from_user_or_community;
 use crate::{
-  activities::{generate_activity_id, send_lemmy_activity},
+  activities::generate_activity_id,
   insert_received_activity,
   protocol::activities::following::{follow::Follow, reject::RejectFollow},
 };
@@ -32,7 +33,7 @@ impl RejectFollow {
       )?,
     };
     let inbox = ActivitySendTargets::to_inbox(person.shared_inbox_or_inbox());
-    send_lemmy_activity(context, reject, &user_or_community, inbox, true).await
+    send_activity_from_user_or_community(context, reject, user_or_community, inbox).await
   }
 }
 

Diff for: crates/apub/src/activities/following/reject.rs

@@ -1,6 +1,6 @@
 use crate::{
   activities::{generate_activity_id, send_lemmy_activity, verify_person},
-  fetcher::user_or_community::UserOrCommunity,
+  fetcher::UserOrCommunity,
   insert_received_activity,
   objects::{community::ApubCommunity, person::ApubPerson},
   protocol::activities::following::{follow::Follow, undo_follow::UndoFollow},
@@ -74,10 +74,10 @@ impl ActivityHandler for UndoFollow {
     let object = self.object.object.dereference(context).await?;
 
     match object {
-      UserOrCommunity::User(u) => {
+      UserOrCommunity::Left(u) => {
         PersonActions::unfollow(&mut context.pool(), person.id, u.id).await?;
       }
-      UserOrCommunity::Community(c) => {
+      UserOrCommunity::Right(c) => {
         CommunityActions::unfollow(&mut context.pool(), person.id, c.id).await?;
       }
     }

Diff for: crates/apub/src/activities/following/undo_follow.rs

@@ -113,7 +113,11 @@ pub(crate) fn verify_is_public(to: &[Url], cc: &[Url]) -> LemmyResult<()> {
 
 /// Returns an error if object visibility doesnt match community visibility
 /// (ie content in private community must also be private).
-pub(crate) fn verify_visibility(to: &[Url], cc: &[Url], community: &Community) -> LemmyResult<()> {
+pub(crate) fn verify_visibility(
+  to: &[Url],
+  cc: &[Url],
+  community: &ApubCommunity,
+) -> LemmyResult<()> {
   use CommunityVisibility::*;
   let object_is_public = [to, cc].iter().any(|set| set.contains(&public()));
   match community.visibility {
@@ -186,9 +190,8 @@ async fn send_lemmy_activity<Activity, ActorT>(
   sensitive: bool,
 ) -> LemmyResult<()>
 where
-  Activity: ActivityHandler + Serialize + Send + Sync + Clone,
+  Activity: ActivityHandler + Serialize + Send + Sync + Clone + ActivityHandler<Error = LemmyError>,
   ActorT: Actor + GetActorType,
-  Activity: ActivityHandler<Error = LemmyError>,
 {
   info!("Saving outgoing activity to queue {}", activity.id());
 

Diff for: crates/apub/src/activities/mod.rs

@@ -1,7 +1,7 @@
 use crate::{
   activities::community::send_activity_in_community,
   activity_lists::AnnouncableActivities,
-  fetcher::post_or_comment::PostOrComment,
+  fetcher::PostOrComment,
   objects::{comment::ApubComment, community::ApubCommunity, person::ApubPerson, post::ApubPost},
   protocol::activities::voting::{
     undo_vote::UndoVote,

Diff for: crates/apub/src/activities/voting/mod.rs

@@ -66,8 +66,8 @@ impl ActivityHandler for UndoVote {
     let actor = self.actor.dereference(context).await?;
     let object = self.object.object.dereference(context).await?;
     match object {
-      PostOrComment::Post(p) => undo_vote_post(actor, &p, context).await,
-      PostOrComment::Comment(c) => undo_vote_comment(actor, &c, context).await,
+      PostOrComment::Left(p) => undo_vote_post(actor, &p, context).await,
+      PostOrComment::Right(c) => undo_vote_comment(actor, &c, context).await,
     }
   }
 }

Diff for: crates/apub/src/activities/voting/undo_vote.rs

@@ -72,8 +72,8 @@ impl ActivityHandler for Vote {
       .unwrap_or_default();
 
     let (downvote_setting, upvote_setting) = match object {
-      PostOrComment::Post(_) => (local_site.post_downvotes, local_site.post_upvotes),
-      PostOrComment::Comment(_) => (local_site.comment_downvotes, local_site.comment_upvotes),
+      PostOrComment::Left(_) => (local_site.post_downvotes, local_site.post_upvotes),
+      PostOrComment::Right(_) => (local_site.comment_downvotes, local_site.comment_upvotes),
     };
 
     // Don't allow dislikes for either disabled, or local only votes
@@ -83,14 +83,14 @@ impl ActivityHandler for Vote {
     if downvote_fail || upvote_fail {
       // If this is a rejection, undo the vote
       match object {
-        PostOrComment::Post(p) => undo_vote_post(actor, &p, context).await,
-        PostOrComment::Comment(c) => undo_vote_comment(actor, &c, context).await,
+        PostOrComment::Left(p) => undo_vote_post(actor, &p, context).await,
+        PostOrComment::Right(c) => undo_vote_comment(actor, &c, context).await,
       }
     } else {
       // Otherwise apply the vote normally
       match object {
-        PostOrComment::Post(p) => vote_post(&self.kind, actor, &p, context).await,
-        PostOrComment::Comment(c) => vote_comment(&self.kind, actor, &c, context).await,
+        PostOrComment::Left(p) => vote_post(&self.kind, actor, &p, context).await,
+        PostOrComment::Right(c) => vote_comment(&self.kind, actor, &c, context).await,
       }
     }
   }

Diff for: crates/apub/src/activities/voting/vote.rs

@@ -1,7 +1,7 @@
 use crate::fetcher::{
-  post_or_comment::PostOrComment,
   search::{search_query_to_object_id, search_query_to_object_id_local, SearchableObjects},
-  user_or_community::UserOrCommunity,
+  PostOrComment,
+  UserOrCommunity,
 };
 use activitypub_federation::config::Data;
 use actix_web::web::{Json, Query};
@@ -56,17 +56,17 @@ async fn convert_response(
   let is_admin = local_user.clone().map(|l| l.admin).unwrap_or_default();
 
   match object {
-    SearchableObjects::PostOrComment(pc) => match *pc {
-      PostOrComment::Post(p) => {
+    SearchableObjects::Left(pc) => match pc {
+      PostOrComment::Left(p) => {
         res.post = Some(PostView::read(pool, p.id, local_user.as_ref(), is_admin).await?)
       }
-      PostOrComment::Comment(c) => {
+      PostOrComment::Right(c) => {
         res.comment = Some(CommentView::read(pool, c.id, local_user.as_ref()).await?)
       }
     },
-    SearchableObjects::PersonOrCommunity(pc) => match *pc {
-      UserOrCommunity::User(u) => res.person = Some(PersonView::read(pool, u.id, is_admin).await?),
-      UserOrCommunity::Community(c) => {
+    SearchableObjects::Right(pc) => match pc {
+      UserOrCommunity::Left(u) => res.person = Some(PersonView::read(pool, u.id, is_admin).await?),
+      UserOrCommunity::Right(c) => {
         res.community = Some(CommunityView::read(pool, c.id, local_user.as_ref(), is_admin).await?)
       }
     },

Diff for: crates/apub/src/api/resolve_object.rs

@@ -1,5 +1,5 @@
-use super::{search::SearchableObjects, user_or_community::UserOrCommunity};
-use crate::fetcher::post_or_comment::PostOrComment;
+use super::{search::SearchableObjects, UserOrCommunity};
+use crate::fetcher::PostOrComment;
 use activitypub_federation::{config::Data, fetch::object_id::ObjectId};
 use lemmy_api_common::context::LemmyContext;
 use lemmy_db_schema::{newtypes::InstanceId, source::instance::Instance};
@@ -57,17 +57,17 @@ pub(crate) async fn to_local_url(url: &str, context: &Data<LemmyContext>) -> Opt
   }
   let dereferenced = object_id.dereference_local(context).await.ok()?;
   match dereferenced {
-    SearchableObjects::PostOrComment(pc) => match *pc {
-      PostOrComment::Post(post) => post.local_url(context.settings()),
-      PostOrComment::Comment(comment) => comment.local_url(context.settings()),
+    SearchableObjects::Left(pc) => match pc {
+      PostOrComment::Left(post) => post.local_url(context.settings()),
+      PostOrComment::Right(comment) => comment.local_url(context.settings()),
     }
     .ok()
     .map(Into::into),
-    SearchableObjects::PersonOrCommunity(pc) => match *pc {
-      UserOrCommunity::User(user) => {
+    SearchableObjects::Right(pc) => match pc {
+      UserOrCommunity::Left(user) => {
         format_actor_url(&user.name, "u", user.instance_id, context).await
       }
-      UserOrCommunity::Community(community) => {
+      UserOrCommunity::Right(community) => {
         format_actor_url(&community.name, "c", community.instance_id, context).await
       }
     }