show reposts in author feeds

migrations/2025-09-27-171241_post-tweaks/down.sql

···
 alter table posts
     drop column mentions,
-    drop column violates_threadgate;
+    drop column violates_threadgate;
+
+drop trigger t_author_feed_ins_post on posts;
+drop trigger t_author_feed_del_post on posts;
+drop trigger t_author_feed_ins_repost on reposts;
+drop trigger t_author_feed_del_repost on reposts;
+
+drop function f_author_feed_ins_post;
+drop function f_author_feed_del_post;
+drop function f_author_feed_ins_repost;
+drop function f_author_feed_del_repost;
+
+drop table author_feeds;

migrations/2025-09-27-171241_post-tweaks/up.sql

···
 alter table posts
     add column mentions            text[],
-    add column violates_threadgate bool not null default false;
+    add column violates_threadgate bool not null default false;
+
+create table author_feeds
+(
+    uri     text primary key,
+    cid     text        not null,
+    post    text        not null,
+    did     text        not null,
+    typ     text        not null,
+    sort_at timestamptz not null
+);
+
+-- author_feeds post triggers
+create function f_author_feed_ins_post() returns trigger
+    language plpgsql as
+$$
+begin
+    insert into author_feeds (uri, cid, post, did, typ, sort_at)
+    VALUES (NEW.at_uri, NEW.cid, NEW.at_uri, NEW.did, 'post', NEW.created_at)
+    on conflict do nothing;
+    return NEW;
+end;
+$$;
+
+create trigger t_author_feed_ins_post
+    before insert
+    on posts
+    for each row
+execute procedure f_author_feed_ins_post();
+
+create function f_author_feed_del_post() returns trigger
+    language plpgsql as
+$$
+begin
+    delete from author_feeds where did = OLD.did and item = OLD.at_uri and typ = 'post';
+    return OLD;
+end;
+$$;
+
+create trigger t_author_feed_del_post
+    before delete
+    on posts
+    for each row
+execute procedure f_author_feed_del_post();
+
+-- author_feeds repost triggers
+create function f_author_feed_ins_repost() returns trigger
+    language plpgsql as
+$$
+begin
+    insert into author_feeds (uri, cid, post, did, typ, sort_at)
+    VALUES ('at://' || NEW.did || 'app.bsky.feed.repost' || NEW.rkey, NEW.post_cid, NEW.post, NEW.did, 'repost', NEW.created_at)
+    on conflict do nothing;
+    return NEW;
+end;
+$$;
+
+create trigger t_author_feed_ins_repost
+    before insert
+    on reposts
+    for each row
+execute procedure f_author_feed_ins_repost();
+
+create function f_author_feed_del_repost() returns trigger
+    language plpgsql as
+$$
+begin
+    delete from author_feeds where did = OLD.did and item = OLD.post and typ = 'repost';
+    return OLD;
+end;
+$$;
+
+create trigger t_author_feed_del_repost
+    before delete
+    on reposts
+    for each row
+execute procedure f_author_feed_del_repost();

parakeet-db/src/models.rs

···
     pub subject_type: &'a str,
     pub tags: Vec<String>,
 }
+
+#[derive(Debug, Queryable, Selectable, Identifiable)]
+#[diesel(table_name = crate::schema::author_feeds)]
+#[diesel(primary_key(uri))]
+#[diesel(check_for_backend(diesel::pg::Pg))]
+pub struct AuthorFeedItem {
+    pub uri: String,
+    pub cid: String,
+    pub post: String,
+    pub did: String,
+    pub typ: String,
+    pub sort_at: DateTime<Utc>,
+}

parakeet-db/src/schema.rs

···
 }
 
 diesel::table! {
+    author_feeds (uri) {
+        uri -> Text,
+        cid -> Text,
+        post -> Text,
+        did -> Text,
+        typ -> Text,
+        sort_at -> Timestamptz,
+    }
+}
+
+diesel::table! {
     backfill (repo, repo_ver) {
         repo -> Text,
         repo_ver -> Text,
···
 
 diesel::allow_tables_to_appear_in_same_query!(
     actors,
+    author_feeds,
     backfill,
     backfill_jobs,
     blocks,

parakeet/src/xrpc/app_bsky/feed/posts.rs

···
     BlockedAuthor, FeedReasonRepost, FeedSkeletonResponse, FeedViewPost, FeedViewPostReason,
     PostView, SkeletonReason, ThreadViewPost, ThreadViewPostType, ThreadgateView,
 };
-use parakeet_db::schema;
+use parakeet_db::{models, schema};
 use reqwest::Url;
 use serde::{Deserialize, Serialize};
 use std::collections::HashMap;
···
 
     let limit = query.limit.unwrap_or(50).clamp(1, 100);
 
-    let mut posts_query = schema::posts::table
-        .select((schema::posts::created_at, schema::posts::at_uri))
-        .filter(schema::posts::did.eq(did))
+    let mut posts_query = schema::author_feeds::table
+        .select(models::AuthorFeedItem::as_select())
+        .left_join(schema::posts::table.on(schema::posts::at_uri.eq(schema::author_feeds::post)))
+        .filter(schema::author_feeds::did.eq(&did))
         .into_boxed();
 
     if let Some(cursor) = datetime_cursor(query.cursor.as_ref()) {
-        posts_query = posts_query.filter(schema::posts::created_at.lt(cursor));
+        posts_query = posts_query.filter(schema::author_feeds::sort_at.lt(cursor));
     }
 
     posts_query = match query.filter {
-        GetAuthorFeedFilter::PostsWithReplies => posts_query,
+        GetAuthorFeedFilter::PostsWithReplies => {
+            posts_query.filter(schema::author_feeds::typ.eq("post"))
+        }
         GetAuthorFeedFilter::PostsNoReplies => {
             posts_query.filter(schema::posts::parent_uri.is_null())
         }
-        GetAuthorFeedFilter::PostsWithMedia => posts_query.filter(embed_type_filter(&[
-            "app.bsky.embed.video",
-            "app.bsky.embed.images",
-        ])),
+        GetAuthorFeedFilter::PostsWithMedia => posts_query.filter(
+            embed_type_filter(&["app.bsky.embed.video", "app.bsky.embed.images"])
+                .and(schema::author_feeds::typ.eq("post")),
+        ),
         GetAuthorFeedFilter::PostsAndAuthorThreads => posts_query.filter(
             (schema::posts::parent_uri
-                .like(format!("at://{}/%", &query.actor))
+                .like(format!("at://{did}/%"))
                 .or(schema::posts::parent_uri.is_null()))
             .and(
                 schema::posts::root_uri
-                    .like(format!("at://{}/%", &query.actor))
+                    .like(format!("at://{did}/%"))
                     .or(schema::posts::root_uri.is_null()),
             ),
         ),
-        GetAuthorFeedFilter::PostsWithVideo => {
-            posts_query.filter(embed_type_filter(&["app.bsky.embed.video"]))
-        }
+        GetAuthorFeedFilter::PostsWithVideo => posts_query.filter(
+            embed_type_filter(&["app.bsky.embed.video"]).and(schema::author_feeds::typ.eq("post")),
+        ),
     };
 
     let results = posts_query
-        .order(schema::posts::created_at.desc())
+        .order(schema::author_feeds::sort_at.desc())
         .limit(limit as i64)
-        .load::<(chrono::DateTime<chrono::Utc>, String)>(&mut conn)
+        .load(&mut conn)
         .await?;
 
     let cursor = results
         .last()
-        .map(|(last, _)| last.timestamp_millis().to_string());
+        .map(|item| item.sort_at.timestamp_millis().to_string());
 
     let at_uris = results
         .iter()
-        .map(|(_, uri)| uri.clone())
+        .map(|item| item.post.clone())
         .collect::<Vec<_>>();
+
+    // get the actor for if we have reposted
+    let profile = hyd.hydrate_profile_basic(did).await.ok_or(Error::server_error(None))?;
 
     let mut posts = hyd.hydrate_feed_posts(at_uris).await;
 
     let mut feed: Vec<_> = results
         .into_iter()
-        .filter_map(|(_, uri)| posts.remove(&uri))
+        .filter_map(|item| {
+            posts.remove(&item.post).map(|mut fvp| {
+                if item.typ == "repost" {
+                    fvp.reason = Some(FeedViewPostReason::Repost(FeedReasonRepost {
+                        by: profile.clone(),
+                        uri: Some(item.uri),
+                        cid: Some(item.cid),
+                        indexed_at: Default::default(),
+                    }))
+                }
+                fvp
+            })
+        })
         .collect();
 
     if let Some(post) = pin {