Removing old user_mention_view.

lemmy_api/src/user.rs

@@ -31,13 +31,13 @@ use lemmy_db::{
     user::*,
     user_mention::*,
   },
-  user_mention_view::*,
   views::{
     comment_view::CommentQueryBuilder,
     community_follower_view::CommunityFollowerView,
     community_moderator_view::CommunityModeratorView,
     post_view::PostQueryBuilder,
     site_view::SiteView,
+    user_mention_view::{UserMentionQueryBuilder, UserMentionView},
     user_view::{UserViewDangerous, UserViewSafe},
   },
   Crud,
@@ -774,7 +774,7 @@ impl Perform for GetUserMentions {
     let unread_only = data.unread_only;
     let user_id = user.id;
     let mentions = blocking(context.pool(), move |conn| {
-      UserMentionQueryBuilder::create(conn, user_id)
+      UserMentionQueryBuilder::create(conn, Some(user_id), user_id)
         .sort(&sort)
         .unread_only(unread_only)
         .page(page)
@@ -819,13 +819,11 @@ impl Perform for MarkUserMentionAsRead {
     let user_mention_id = read_user_mention.id;
     let user_id = user.id;
     let user_mention_view = blocking(context.pool(), move |conn| {
-      UserMentionView::read(conn, user_mention_id, user_id)
+      UserMentionView::read(conn, user_mention_id, Some(user_id))
     })
     .await??;
 
-    Ok(UserMentionResponse {
+    Ok(UserMentionResponse { user_mention_view })
-      mention: user_mention_view,
-    })
   }
 }
 

lemmy_db/src/lib.rs

@@ -15,7 +15,6 @@ pub mod comment_report;
 pub mod moderator_views;
 pub mod post_report;
 pub mod private_message_view;
-pub mod user_mention_view;
 
 pub mod aggregates;
 pub mod schema;

lemmy_db/src/schema.rs

@@ -617,6 +617,7 @@ table! {
 
 joinable!(comment_alias_1 -> user_alias_1 (creator_id));
 joinable!(comment -> comment_alias_1 (parent_id));
+joinable!(user_mention -> user_alias_1 (recipient_id));
 
 joinable!(comment -> post (post_id));
 joinable!(comment -> user_ (creator_id));

lemmy_db/src/source/user_mention.rs

@@ -1,8 +1,9 @@
 use super::comment::Comment;
 use crate::{schema::user_mention, Crud};
 use diesel::{dsl::*, result::Error, *};
+use serde::Serialize;
 
-#[derive(Queryable, Associations, Identifiable, PartialEq, Debug)]
+#[derive(Clone, Queryable, Associations, Identifiable, PartialEq, Debug, Serialize)]
 #[belongs_to(Comment)]
 #[table_name = "user_mention"]
 pub struct UserMention {

lemmy_db/src/user_mention_view.rs

@@ -1,231 +0,0 @@
-use crate::{limit_and_offset, MaybeOptional, SortType};
-use diesel::{dsl::*, pg::Pg, result::Error, *};
-use serde::Serialize;
-
-// The faked schema since diesel doesn't do views
-table! {
-  user_mention_view (id) {
-    id -> Int4,
-    user_mention_id -> Int4,
-    creator_id -> Int4,
-    creator_actor_id -> Text,
-    creator_local -> Bool,
-    post_id -> Int4,
-    post_name -> Varchar,
-    parent_id -> Nullable<Int4>,
-    content -> Text,
-    removed -> Bool,
-    read -> Bool,
-    published -> Timestamp,
-    updated -> Nullable<Timestamp>,
-    deleted -> Bool,
-    community_id -> Int4,
-    community_actor_id -> Text,
-    community_local -> Bool,
-    community_name -> Varchar,
-    community_icon -> Nullable<Text>,
-    banned -> Bool,
-    banned_from_community -> Bool,
-    creator_name -> Varchar,
-    creator_preferred_username -> Nullable<Varchar>,
-    creator_avatar -> Nullable<Text>,
-    score -> BigInt,
-    upvotes -> BigInt,
-    downvotes -> BigInt,
-    hot_rank -> Int4,
-    hot_rank_active -> Int4,
-    user_id -> Nullable<Int4>,
-    my_vote -> Nullable<Int4>,
-    saved -> Nullable<Bool>,
-    recipient_id -> Int4,
-    recipient_actor_id -> Text,
-    recipient_local -> Bool,
-  }
-}
-
-table! {
-  user_mention_fast_view (id) {
-    id -> Int4,
-    user_mention_id -> Int4,
-    creator_id -> Int4,
-    creator_actor_id -> Text,
-    creator_local -> Bool,
-    post_id -> Int4,
-    post_name -> Varchar,
-    parent_id -> Nullable<Int4>,
-    content -> Text,
-    removed -> Bool,
-    read -> Bool,
-    published -> Timestamp,
-    updated -> Nullable<Timestamp>,
-    deleted -> Bool,
-    community_id -> Int4,
-    community_actor_id -> Text,
-    community_local -> Bool,
-    community_name -> Varchar,
-    community_icon -> Nullable<Text>,
-    banned -> Bool,
-    banned_from_community -> Bool,
-    creator_name -> Varchar,
-    creator_preferred_username -> Nullable<Varchar>,
-    creator_avatar -> Nullable<Text>,
-    score -> BigInt,
-    upvotes -> BigInt,
-    downvotes -> BigInt,
-    hot_rank -> Int4,
-    hot_rank_active -> Int4,
-    user_id -> Nullable<Int4>,
-    my_vote -> Nullable<Int4>,
-    saved -> Nullable<Bool>,
-    recipient_id -> Int4,
-    recipient_actor_id -> Text,
-    recipient_local -> Bool,
-  }
-}
-
-#[derive(Queryable, Identifiable, PartialEq, Debug, Serialize, QueryableByName, Clone)]
-#[table_name = "user_mention_fast_view"]
-pub struct UserMentionView {
-  pub id: i32,
-  pub user_mention_id: i32,
-  pub creator_id: i32,
-  pub creator_actor_id: String,
-  pub creator_local: bool,
-  pub post_id: i32,
-  pub post_name: String,
-  pub parent_id: Option<i32>,
-  pub content: String,
-  pub removed: bool,
-  pub read: bool,
-  pub published: chrono::NaiveDateTime,
-  pub updated: Option<chrono::NaiveDateTime>,
-  pub deleted: bool,
-  pub community_id: i32,
-  pub community_actor_id: String,
-  pub community_local: bool,
-  pub community_name: String,
-  pub community_icon: Option<String>,
-  pub banned: bool,
-  pub banned_from_community: bool,
-  pub creator_name: String,
-  pub creator_preferred_username: Option<String>,
-  pub creator_avatar: Option<String>,
-  pub score: i64,
-  pub upvotes: i64,
-  pub downvotes: i64,
-  pub hot_rank: i32,
-  pub hot_rank_active: i32,
-  pub user_id: Option<i32>,
-  pub my_vote: Option<i32>,
-  pub saved: Option<bool>,
-  pub recipient_id: i32,
-  pub recipient_actor_id: String,
-  pub recipient_local: bool,
-}
-
-pub struct UserMentionQueryBuilder<'a> {
-  conn: &'a PgConnection,
-  query: super::user_mention_view::user_mention_fast_view::BoxedQuery<'a, Pg>,
-  for_user_id: i32,
-  sort: &'a SortType,
-  unread_only: bool,
-  page: Option<i64>,
-  limit: Option<i64>,
-}
-
-impl<'a> UserMentionQueryBuilder<'a> {
-  pub fn create(conn: &'a PgConnection, for_user_id: i32) -> Self {
-    use super::user_mention_view::user_mention_fast_view::dsl::*;
-
-    let query = user_mention_fast_view.into_boxed();
-
-    UserMentionQueryBuilder {
-      conn,
-      query,
-      for_user_id,
-      sort: &SortType::New,
-      unread_only: false,
-      page: None,
-      limit: None,
-    }
-  }
-
-  pub fn sort(mut self, sort: &'a SortType) -> Self {
-    self.sort = sort;
-    self
-  }
-
-  pub fn unread_only(mut self, unread_only: bool) -> Self {
-    self.unread_only = unread_only;
-    self
-  }
-
-  pub fn page<T: MaybeOptional<i64>>(mut self, page: T) -> Self {
-    self.page = page.get_optional();
-    self
-  }
-
-  pub fn limit<T: MaybeOptional<i64>>(mut self, limit: T) -> Self {
-    self.limit = limit.get_optional();
-    self
-  }
-
-  pub fn list(self) -> Result<Vec<UserMentionView>, Error> {
-    use super::user_mention_view::user_mention_fast_view::dsl::*;
-
-    let mut query = self.query;
-
-    if self.unread_only {
-      query = query.filter(read.eq(false));
-    }
-
-    query = query
-      .filter(user_id.eq(self.for_user_id))
-      .filter(recipient_id.eq(self.for_user_id));
-
-    query = match self.sort {
-      SortType::Hot => query
-        .order_by(hot_rank.desc())
-        .then_order_by(published.desc()),
-      SortType::Active => query
-        .order_by(hot_rank_active.desc())
-        .then_order_by(published.desc()),
-      SortType::New => query.order_by(published.desc()),
-      SortType::TopAll => query.order_by(score.desc()),
-      SortType::TopYear => query
-        .filter(published.gt(now - 1.years()))
-        .order_by(score.desc()),
-      SortType::TopMonth => query
-        .filter(published.gt(now - 1.months()))
-        .order_by(score.desc()),
-      SortType::TopWeek => query
-        .filter(published.gt(now - 1.weeks()))
-        .order_by(score.desc()),
-      SortType::TopDay => query
-        .filter(published.gt(now - 1.days()))
-        .order_by(score.desc()),
-      // _ => query.order_by(published.desc()),
-    };
-
-    let (limit, offset) = limit_and_offset(self.page, self.limit);
-    query
-      .limit(limit)
-      .offset(offset)
-      .load::<UserMentionView>(self.conn)
-  }
-}
-
-impl UserMentionView {
-  pub fn read(
-    conn: &PgConnection,
-    from_user_mention_id: i32,
-    from_recipient_id: i32,
-  ) -> Result<Self, Error> {
-    use super::user_mention_view::user_mention_fast_view::dsl::*;
-
-    user_mention_fast_view
-      .filter(user_mention_id.eq(from_user_mention_id))
-      .filter(user_id.eq(from_recipient_id))
-      .first::<Self>(conn)
-  }
-}

lemmy_db/src/views/mod.rs

@@ -5,6 +5,7 @@ pub mod community_user_ban_view;
 pub mod community_view;
 pub mod post_view;
 pub mod site_view;
+pub mod user_mention_view;
 pub mod user_view;
 
 pub(crate) trait ViewToVec {

lemmy_db/src/views/user_mention_view.rs

@@ -0,0 +1,552 @@
+use crate::{
+  aggregates::comment_aggregates::CommentAggregates,
+  functions::hot_rank,
+  limit_and_offset,
+  schema::{
+    comment,
+    comment_aggregates,
+    comment_like,
+    comment_saved,
+    community,
+    community_follower,
+    community_user_ban,
+    post,
+    user_,
+    user_alias_1,
+    user_mention,
+  },
+  source::{
+    comment::{Comment, CommentSaved},
+    community::{Community, CommunityFollower, CommunitySafe, CommunityUserBan},
+    post::Post,
+    user::{UserAlias1, UserSafe, UserSafeAlias1, User_},
+    user_mention::UserMention,
+  },
+  views::ViewToVec,
+  MaybeOptional,
+  SortType,
+  ToSafe,
+};
+use diesel::{result::Error, *};
+use serde::Serialize;
+
+#[derive(Debug, PartialEq, Serialize, Clone)]
+pub struct UserMentionView {
+  pub user_mention: UserMention,
+  pub comment: Comment,
+  pub creator: UserSafe,
+  pub post: Post,
+  pub community: CommunitySafe,
+  pub recipient: UserSafeAlias1,
+  pub counts: CommentAggregates,
+  pub creator_banned_from_community: bool, // Left Join to CommunityUserBan
+  pub subscribed: bool,                    // Left join to CommunityFollower
+  pub saved: bool,                         // Left join to CommentSaved
+  pub my_vote: Option<i16>,                // Left join to CommentLike
+}
+
+type UserMentionViewTuple = (
+  UserMention,
+  Comment,
+  UserSafe,
+  Post,
+  CommunitySafe,
+  UserSafeAlias1,
+  CommentAggregates,
+  Option<CommunityUserBan>,
+  Option<CommunityFollower>,
+  Option<CommentSaved>,
+  Option<i16>,
+);
+
+impl UserMentionView {
+  pub fn read(
+    conn: &PgConnection,
+    user_mention_id: i32,
+    my_user_id: Option<i32>,
+  ) -> Result<Self, Error> {
+    // The left join below will return None in this case
+    let user_id_join = my_user_id.unwrap_or(-1);
+
+    let (
+      user_mention,
+      comment,
+      creator,
+      post,
+      community,
+      recipient,
+      counts,
+      creator_banned_from_community,
+      subscribed,
+      saved,
+      my_vote,
+    ) = user_mention::table
+      .find(user_mention_id)
+      .inner_join(comment::table)
+      .inner_join(user_::table.on(comment::creator_id.eq(user_::id)))
+      .inner_join(post::table.on(comment::post_id.eq(post::id)))
+      .inner_join(community::table.on(post::community_id.eq(community::id)))
+      .inner_join(user_alias_1::table)
+      .inner_join(comment_aggregates::table.on(comment::id.eq(comment_aggregates::comment_id)))
+      .left_join(
+        community_user_ban::table.on(
+          community::id
+            .eq(community_user_ban::community_id)
+            .and(community_user_ban::user_id.eq(comment::creator_id)),
+        ),
+      )
+      .left_join(
+        community_follower::table.on(
+          post::community_id
+            .eq(community_follower::community_id)
+            .and(community_follower::user_id.eq(user_id_join)),
+        ),
+      )
+      .left_join(
+        comment_saved::table.on(
+          comment::id
+            .eq(comment_saved::comment_id)
+            .and(comment_saved::user_id.eq(user_id_join)),
+        ),
+      )
+      .left_join(
+        comment_like::table.on(
+          comment::id
+            .eq(comment_like::comment_id)
+            .and(comment_like::user_id.eq(user_id_join)),
+        ),
+      )
+      .select((
+        user_mention::all_columns,
+        comment::all_columns,
+        User_::safe_columns_tuple(),
+        post::all_columns,
+        Community::safe_columns_tuple(),
+        UserAlias1::safe_columns_tuple(),
+        comment_aggregates::all_columns,
+        community_user_ban::all_columns.nullable(),
+        community_follower::all_columns.nullable(),
+        comment_saved::all_columns.nullable(),
+        comment_like::score.nullable(),
+      ))
+      .first::<UserMentionViewTuple>(conn)?;
+
+    Ok(UserMentionView {
+      user_mention,
+      comment,
+      creator,
+      post,
+      community,
+      recipient,
+      counts,
+      creator_banned_from_community: creator_banned_from_community.is_some(),
+      subscribed: subscribed.is_some(),
+      saved: saved.is_some(),
+      my_vote,
+    })
+  }
+}
+
+mod join_types {
+  use crate::schema::{
+    comment,
+    comment_aggregates,
+    comment_like,
+    comment_saved,
+    community,
+    community_follower,
+    community_user_ban,
+    post,
+    user_,
+    user_alias_1,
+    user_mention,
+  };
+  use diesel::{
+    pg::Pg,
+    query_builder::BoxedSelectStatement,
+    query_source::joins::{Inner, Join, JoinOn, LeftOuter},
+    sql_types::*,
+  };
+
+  // /// TODO awful, but necessary because of the boxed join
+  pub(super) type BoxedUserMentionJoin<'a> = BoxedSelectStatement<
+    'a,
+    (
+      (Integer, Integer, Integer, Bool, Timestamp),
+      (
+        Integer,
+        Integer,
+        Integer,
+        Nullable<Integer>,
+        Text,
+        Bool,
+        Bool,
+        Timestamp,
+        Nullable<Timestamp>,
+        Bool,
+        Text,
+        Bool,
+      ),
+      (
+        Integer,
+        Text,
+        Nullable<Text>,
+        Nullable<Text>,
+        Bool,
+        Bool,
+        Timestamp,
+        Nullable<Timestamp>,
+        Nullable<Text>,
+        Text,
+        Nullable<Text>,
+        Bool,
+        Nullable<Text>,
+        Bool,
+      ),
+      (
+        Integer,
+        Text,
+        Nullable<Text>,
+        Nullable<Text>,
+        Integer,
+        Integer,
+        Bool,
+        Bool,
+        Timestamp,
+        Nullable<Timestamp>,
+        Bool,
+        Bool,
+        Bool,
+        Nullable<Text>,
+        Nullable<Text>,
+        Nullable<Text>,
+        Nullable<Text>,
+        Text,
+        Bool,
+      ),
+      (
+        Integer,
+        Text,
+        Text,
+        Nullable<Text>,
+        Integer,
+        Integer,
+        Bool,
+        Timestamp,
+        Nullable<Timestamp>,
+        Bool,
+        Bool,
+        Text,
+        Bool,
+        Nullable<Text>,
+        Nullable<Text>,
+      ),
+      (
+        Integer,
+        Text,
+        Nullable<Text>,
+        Nullable<Text>,
+        Bool,
+        Bool,
+        Timestamp,
+        Nullable<Timestamp>,
+        Nullable<Text>,
+        Text,
+        Nullable<Text>,
+        Bool,
+        Nullable<Text>,
+        Bool,
+      ),
+      (Integer, Integer, BigInt, BigInt, BigInt),
+      Nullable<(Integer, Integer, Integer, Timestamp)>,
+      Nullable<(Integer, Integer, Integer, Timestamp, Nullable<Bool>)>,
+      Nullable<(Integer, Integer, Integer, Timestamp)>,
+      Nullable<SmallInt>,
+    ),
+    JoinOn<
+      Join<
+        JoinOn<
+          Join<
+            JoinOn<
+              Join<
+                JoinOn<
+                  Join<
+                    JoinOn<
+                      Join<
+                        JoinOn<
+                          Join<
+                            JoinOn<
+                              Join<
+                                JoinOn<
+                                  Join<
+                                    JoinOn<
+                                      Join<
+                                        JoinOn<
+                                          Join<user_mention::table, comment::table, Inner>,
+                                          diesel::expression::operators::Eq<
+                                            diesel::expression::nullable::Nullable<
+                                              user_mention::columns::comment_id,
+                                            >,
+                                            diesel::expression::nullable::Nullable<
+                                              comment::columns::id,
+                                            >,
+                                          >,
+                                        >,
+                                        user_::table,
+                                        Inner,
+                                      >,
+                                      diesel::expression::operators::Eq<
+                                        comment::columns::creator_id,
+                                        user_::columns::id,
+                                      >,
+                                    >,
+                                    post::table,
+                                    Inner,
+                                  >,
+                                  diesel::expression::operators::Eq<
+                                    comment::columns::post_id,
+                                    post::columns::id,
+                                  >,
+                                >,
+                                community::table,
+                                Inner,
+                              >,
+                              diesel::expression::operators::Eq<
+                                post::columns::community_id,
+                                community::columns::id,
+                              >,
+                            >,
+                            user_alias_1::table,
+                            Inner,
+                          >,
+                          diesel::expression::operators::Eq<
+                            diesel::expression::nullable::Nullable<
+                              user_mention::columns::recipient_id,
+                            >,
+                            diesel::expression::nullable::Nullable<user_alias_1::columns::id>,
+                          >,
+                        >,
+                        comment_aggregates::table,
+                        Inner,
+                      >,
+                      diesel::expression::operators::Eq<
+                        comment::columns::id,
+                        comment_aggregates::columns::comment_id,
+                      >,
+                    >,
+                    community_user_ban::table,
+                    LeftOuter,
+                  >,
+                  diesel::expression::operators::And<
+                    diesel::expression::operators::Eq<
+                      community::columns::id,
+                      community_user_ban::columns::community_id,
+                    >,
+                    diesel::expression::operators::Eq<
+                      community_user_ban::columns::user_id,
+                      comment::columns::creator_id,
+                    >,
+                  >,
+                >,
+                community_follower::table,
+                LeftOuter,
+              >,
+              diesel::expression::operators::And<
+                diesel::expression::operators::Eq<
+                  post::columns::community_id,
+                  community_follower::columns::community_id,
+                >,
+                diesel::expression::operators::Eq<
+                  community_follower::columns::user_id,
+                  diesel::expression::bound::Bound<Integer, i32>,
+                >,
+              >,
+            >,
+            comment_saved::table,
+            LeftOuter,
+          >,
+          diesel::expression::operators::And<
+            diesel::expression::operators::Eq<
+              comment::columns::id,
+              comment_saved::columns::comment_id,
+            >,
+            diesel::expression::operators::Eq<
+              comment_saved::columns::user_id,
+              diesel::expression::bound::Bound<Integer, i32>,
+            >,
+          >,
+        >,
+        comment_like::table,
+        LeftOuter,
+      >,
+      diesel::expression::operators::And<
+        diesel::expression::operators::Eq<comment::columns::id, comment_like::columns::comment_id>,
+        diesel::expression::operators::Eq<
+          comment_like::columns::user_id,
+          diesel::expression::bound::Bound<Integer, i32>,
+        >,
+      >,
+    >,
+    Pg,
+  >;
+}
+
+pub struct UserMentionQueryBuilder<'a> {
+  conn: &'a PgConnection,
+  query: join_types::BoxedUserMentionJoin<'a>,
+  for_recipient_id: i32,
+  sort: &'a SortType,
+  unread_only: bool,
+  page: Option<i64>,
+  limit: Option<i64>,
+}
+
+impl<'a> UserMentionQueryBuilder<'a> {
+  pub fn create(conn: &'a PgConnection, my_user_id: Option<i32>, for_recipient_id: i32) -> Self {
+    // The left join below will return None in this case
+    let user_id_join = my_user_id.unwrap_or(-1);
+
+    let query = user_mention::table
+      .inner_join(comment::table)
+      .inner_join(user_::table.on(comment::creator_id.eq(user_::id)))
+      .inner_join(post::table.on(comment::post_id.eq(post::id)))
+      .inner_join(community::table.on(post::community_id.eq(community::id)))
+      .inner_join(user_alias_1::table)
+      .inner_join(comment_aggregates::table.on(comment::id.eq(comment_aggregates::comment_id)))
+      .left_join(
+        community_user_ban::table.on(
+          community::id
+            .eq(community_user_ban::community_id)
+            .and(community_user_ban::user_id.eq(comment::creator_id)),
+        ),
+      )
+      .left_join(
+        community_follower::table.on(
+          post::community_id
+            .eq(community_follower::community_id)
+            .and(community_follower::user_id.eq(user_id_join)),
+        ),
+      )
+      .left_join(
+        comment_saved::table.on(
+          comment::id
+            .eq(comment_saved::comment_id)
+            .and(comment_saved::user_id.eq(user_id_join)),
+        ),
+      )
+      .left_join(
+        comment_like::table.on(
+          comment::id
+            .eq(comment_like::comment_id)
+            .and(comment_like::user_id.eq(user_id_join)),
+        ),
+      )
+      .select((
+        user_mention::all_columns,
+        comment::all_columns,
+        User_::safe_columns_tuple(),
+        post::all_columns,
+        Community::safe_columns_tuple(),
+        UserAlias1::safe_columns_tuple(),
+        comment_aggregates::all_columns,
+        community_user_ban::all_columns.nullable(),
+        community_follower::all_columns.nullable(),
+        comment_saved::all_columns.nullable(),
+        comment_like::score.nullable(),
+      ))
+      .into_boxed();
+
+    UserMentionQueryBuilder {
+      conn,
+      query,
+      for_recipient_id,
+      sort: &SortType::New,
+      unread_only: false,
+      page: None,
+      limit: None,
+    }
+  }
+
+  pub fn sort(mut self, sort: &'a SortType) -> Self {
+    self.sort = sort;
+    self
+  }
+
+  pub fn unread_only(mut self, unread_only: bool) -> Self {
+    self.unread_only = unread_only;
+    self
+  }
+
+  pub fn page<T: MaybeOptional<i64>>(mut self, page: T) -> Self {
+    self.page = page.get_optional();
+    self
+  }
+
+  pub fn limit<T: MaybeOptional<i64>>(mut self, limit: T) -> Self {
+    self.limit = limit.get_optional();
+    self
+  }
+
+  pub fn list(self) -> Result<Vec<UserMentionView>, Error> {
+    use diesel::dsl::*;
+
+    let mut query = self.query;
+
+    query = query.filter(user_mention::recipient_id.eq(self.for_recipient_id));
+
+    if self.unread_only {
+      query = query.filter(user_mention::read.eq(false));
+    }
+
+    query = match self.sort {
+      SortType::Hot | SortType::Active => query
+        .order_by(hot_rank(comment_aggregates::score, comment::published).desc())
+        .then_order_by(comment::published.desc()),
+      SortType::New => query.order_by(comment::published.desc()),
+      SortType::TopAll => query.order_by(comment_aggregates::score.desc()),
+      SortType::TopYear => query
+        .filter(comment::published.gt(now - 1.years()))
+        .order_by(comment_aggregates::score.desc()),
+      SortType::TopMonth => query
+        .filter(comment::published.gt(now - 1.months()))
+        .order_by(comment_aggregates::score.desc()),
+      SortType::TopWeek => query
+        .filter(comment::published.gt(now - 1.weeks()))
+        .order_by(comment_aggregates::score.desc()),
+      SortType::TopDay => query
+        .filter(comment::published.gt(now - 1.days()))
+        .order_by(comment_aggregates::score.desc()),
+    };
+
+    let (limit, offset) = limit_and_offset(self.page, self.limit);
+
+    let res = query
+      .limit(limit)
+      .offset(offset)
+      .load::<UserMentionViewTuple>(self.conn)?;
+
+    Ok(UserMentionView::to_vec(res))
+  }
+}
+
+impl ViewToVec for UserMentionView {
+  type DbTuple = UserMentionViewTuple;
+  fn to_vec(posts: Vec<Self::DbTuple>) -> Vec<Self> {
+    posts
+      .iter()
+      .map(|a| Self {
+        user_mention: a.0.to_owned(),
+        comment: a.1.to_owned(),
+        creator: a.2.to_owned(),
+        post: a.3.to_owned(),
+        community: a.4.to_owned(),
+        recipient: a.5.to_owned(),
+        counts: a.6.to_owned(),
+        creator_banned_from_community: a.7.is_some(),
+        subscribed: a.8.is_some(),
+        saved: a.9.is_some(),
+        my_vote: a.10,
+      })
+      .collect::<Vec<Self>>()
+  }
+}

lemmy_db/src/views/user_view.rs

@@ -70,6 +70,7 @@ impl UserViewSafe {
   }
 }
 
+// TODO can get rid of this by not boxing the query before the list()
 mod join_types {
   use crate::schema::{user_, user_aggregates};
   use diesel::{

lemmy_structs/src/user.rs

@@ -1,11 +1,11 @@
 use lemmy_db::{
   private_message_view::PrivateMessageView,
-  user_mention_view::UserMentionView,
   views::{
     comment_view::CommentView,
     community_follower_view::CommunityFollowerView,
     community_moderator_view::CommunityModeratorView,
     post_view::PostView,
+    user_mention_view::UserMentionView,
     user_view::{UserViewDangerous, UserViewSafe},
   },
 };
@@ -162,7 +162,7 @@ pub struct MarkUserMentionAsRead {
 
 #[derive(Serialize, Clone)]
 pub struct UserMentionResponse {
-  pub mention: UserMentionView,
+  pub user_mention_view: UserMentionView,
 }
 
 #[derive(Deserialize)]

src/routes/feeds.rs

@@ -5,11 +5,11 @@ use diesel::PgConnection;
 use lemmy_api::claims::Claims;
 use lemmy_db::{
   source::{community::Community, user::User_},
-  user_mention_view::{UserMentionQueryBuilder, UserMentionView},
   views::{
     comment_view::{CommentQueryBuilder, CommentView},
     post_view::{PostQueryBuilder, PostView},
     site_view::SiteView,
+    user_mention_view::{UserMentionQueryBuilder, UserMentionView},
   },
   ListingType,
   SortType,
@@ -253,7 +253,7 @@ fn get_feed_inbox(conn: &PgConnection, jwt: String) -> Result<ChannelBuilder, Le
     .sort(&sort)
     .list()?;
 
-  let mentions = UserMentionQueryBuilder::create(&conn, user_id)
+  let mentions = UserMentionQueryBuilder::create(&conn, Some(user_id), user_id)
     .sort(&sort)
     .list()?;
 
@@ -304,10 +304,15 @@ fn create_reply_and_mention_items(
       let mention_url = format!(
         "{}/post/{}/comment/{}",
         Settings::get().get_protocol_and_hostname(),
-        m.post_id,
+        m.post.id,
-        m.id
+        m.comment.id
       );
-      build_item(&m.creator_name, &m.published, &mention_url, &m.content)
+      build_item(
+        &m.creator.name,
+        &m.comment.published,
+        &mention_url,
+        &m.comment.content,
+      )
     })
     .collect::<Result<Vec<Item>, LemmyError>>()?;