cleanup, timelines

parakeet/src/entities/post.rs

···
         Ok(results)
     }
 
+    /// Convert PostData list to PostViews for timeline
+    pub async fn convert_to_post_views(&self, posts: Vec<PostData>, viewer_did: Option<&str>) -> Vec<PostView> {
+        let viewer_actor_id = if let Some(did) = viewer_did {
+            self.profile_entity.resolve_identifier(did).await.ok()
+        } else {
+            None
+        };
+
+        let mut views = Vec::with_capacity(posts.len());
+        for post_data in posts {
+            views.push(self.post_data_to_view(post_data, viewer_actor_id).await);
+        }
+        views
+    }
+
     /// Convert PostData to PostView
     async fn post_data_to_view(&self, data: PostData, viewer_actor_id: Option<i32>) -> PostView {
         let uri = format!(
···
     }
 
     /// Get timeline posts for a user
-    #[instrument(skip(self))]
-    pub async fn get_timeline_posts(
-        &self,
-        followed_actor_ids: &[i32],
-        cursor_timestamp: Option<&chrono::DateTime<chrono::Utc>>,
-        limit: u8,
-    ) -> Result<Vec<(i32, i64, chrono::DateTime<chrono::Utc>)>> {
-        if followed_actor_ids.is_empty() {
-            return Ok(Vec::new());
-        }
-
-        let mut conn = self.db_pool.get().await?;
-
-        use parakeet_db::schema::posts;
-        use parakeet_db::types::PostStatus;
-        use diesel::prelude::*;
-        use diesel_async::RunQueryDsl;
-
-        let mut query = posts::table
-            .filter(posts::actor_id.eq_any(followed_actor_ids))
-            .filter(posts::status.eq(PostStatus::Complete))
-            .order_by(posts::rkey.desc())
-            .limit(limit as i64 + 1)
-            .into_boxed();
-
-        if let Some(cursor_ts) = cursor_timestamp {
-            let cursor_tid_str = parakeet_db::tid_util::timestamp_to_tid(*cursor_ts);
-            let cursor_tid = parakeet_db::tid_util::decode_tid(&cursor_tid_str).unwrap_or(0);
-            query = query.filter(posts::rkey.lt(cursor_tid));
-        }
-
-        let post_data: Vec<(i32, i64)> = query
-            .select((posts::actor_id, posts::rkey))
-            .load(&mut conn)
-            .await?;
-
-        Ok(post_data.into_iter()
-            .map(|(actor_id, rkey)| {
-                let timestamp = parakeet_db::tid_util::tid_to_datetime(rkey);
-                (actor_id, rkey, timestamp)
-            })
-            .collect())
-    }
-
-    /// Get author feed posts
-    #[instrument(skip(self))]
-    pub async fn get_author_feed(
-        &self,
-        actor_id: i32,
-        cursor_timestamp: Option<&chrono::DateTime<chrono::Utc>>,
-        limit: u8,
-        filter: Option<&str>,
-    ) -> Result<Vec<(i32, i64, chrono::DateTime<chrono::Utc>)>> {
-        let mut conn = self.db_pool.get().await?;
-
-        use parakeet_db::schema::posts;
-        use parakeet_db::types::PostStatus;
-        use diesel::prelude::*;
-        use diesel_async::RunQueryDsl;
-
-        let mut query = posts::table
-            .filter(posts::actor_id.eq(actor_id))
-            .filter(posts::status.eq(PostStatus::Complete))
-            .order_by(posts::rkey.desc())
-            .limit(limit as i64 + 1)
-            .into_boxed();
-
-        // Apply filter
-        match filter {
-            Some("posts_with_replies") => {
-                // Include all posts
-            },
-            Some("posts_with_media") => {
-                use parakeet_db::types::EmbedType;
-                query = query.filter(posts::embed_type.eq(EmbedType::Images));
-            },
-            _ => {
-                // Default: posts_no_replies - exclude replies
-                query = query.filter(posts::parent_post_actor_id.is_null());
-            }
-        }
-
-        if let Some(cursor_ts) = cursor_timestamp {
-            let cursor_tid_str = parakeet_db::tid_util::timestamp_to_tid(*cursor_ts);
-            let cursor_tid = parakeet_db::tid_util::decode_tid(&cursor_tid_str).unwrap_or(0);
-            query = query.filter(posts::rkey.lt(cursor_tid));
-        }
-
-        let post_data: Vec<(i32, i64)> = query
-            .select((posts::actor_id, posts::rkey))
-            .load(&mut conn)
-            .await?;
-
-        Ok(post_data.into_iter()
-            .map(|(actor_id, rkey)| {
-                let timestamp = parakeet_db::tid_util::tid_to_datetime(rkey);
-                (actor_id, rkey, timestamp)
-            })
-            .collect())
-    }
+    /// Note: This method is deprecated in favor of the new ProfileEntity-based approach
 
     /// Get posts quoting another post
     #[instrument(skip(self))]
···
             .await?;
 
         Ok(results)
+    }
+
+    /// Get repost information (what post was reposted)
+    #[instrument(skip(self))]
+    pub async fn get_repost_info(
+        &self,
+        actor_id: i32,
+        rkey: i64,
+    ) -> Result<Option<(i32, i64, chrono::DateTime<chrono::Utc>)>> {
+        let mut conn = self.db_pool.get().await?;
+
+        use parakeet_db::schema::reposts;
+        use diesel::prelude::*;
+        use diesel_async::RunQueryDsl;
+
+        let result = reposts::table
+            .filter(reposts::actor_id.eq(actor_id))
+            .filter(reposts::rkey.eq(rkey))
+            .select((reposts::post_actor_id, reposts::post_rkey))
+            .first::<(i32, i64)>(&mut conn)
+            .await
+            .optional()?;
+
+        Ok(result.map(|(post_actor_id, post_rkey)| {
+            let timestamp = parakeet_db::tid_util::tid_to_datetime(rkey);
+            (post_actor_id, post_rkey, timestamp)
+        }))
     }
 
     /// Search posts by query

parakeet/src/entities/post_tests.rs

···
     Ok(())
 }
 
-#[tokio::test]
-async fn test_get_author_feed_empty() -> eyre::Result<()> {
-    let entity = setup_test_entity().await;
-
-    let actor_id = 999999;
-    let cursor = None;
-    let limit = 50;
-    let filter = Some("posts_no_replies");
-    let result = entity.get_author_feed(actor_id, cursor, limit, filter).await;
-
-    // Non-existent author should return empty
-    assert!(result.is_ok());
-    assert_eq!(result.unwrap().len(), 0);
-    Ok(())
-}
-
 // ============================================================================
 // LIKES AND REPOSTS TESTS
 // ============================================================================
···
 // ============================================================================
 // TIMELINE AND FEED TESTS
 // ============================================================================
-
-#[tokio::test]
-async fn test_get_timeline_posts_empty() -> eyre::Result<()> {
-    let entity = setup_test_entity().await;
-
-    let actor_ids: Vec<i32> = vec![];
-    let cursor = None;
-    let limit = 50;
-    let result = entity.get_timeline_posts(&actor_ids, cursor, limit).await;
-
-    // Empty DIDs should return empty
-    assert!(result.is_ok());
-    assert_eq!(result.unwrap().len(), 0);
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_get_timeline_posts_nonexistent() -> eyre::Result<()> {
-    let entity = setup_test_entity().await;
-
-    let actor_ids = vec![999999, 999998, 999997];
-    let cursor = None;
-    let limit = 50;
-    let result = entity.get_timeline_posts(&actor_ids, cursor, limit).await;
-
-    // Non-existent DIDs should return empty
-    assert!(result.is_ok());
-    assert_eq!(result.unwrap().len(), 0);
-    Ok(())
-}
-
-#[tokio::test]
-async fn test_get_timeline_posts_with_cursor() -> eyre::Result<()> {
-    let entity = setup_test_entity().await;
-
-    let actor_ids = vec![999999];
-    let cursor = Some(&chrono::Utc::now());
-    let limit = 50;
-    let result = entity.get_timeline_posts(&actor_ids, cursor, limit).await;
-
-    // Should handle cursor gracefully
-    assert!(result.is_ok());
-    Ok(())
-}
 
 // ============================================================================
 // QUOTES TESTS

parakeet/src/entities/profile.rs

···
         Ok(known_followers)
     }
 
+    /// Get profiles of accounts this actor follows, with their post rkeys
+    /// This is optimized for timeline generation - returns profiles with their posts
+    pub async fn get_following_with_posts(
+        &self,
+        actor_id: i32,
+        max_follows: usize,
+        max_posts_per_user: usize,
+    ) -> Result<Vec<ProfileData>> {
+        // Get the list of who this actor follows
+        let follows = self.get_following(actor_id, None, max_follows as u8).await?;
+        let followed_actor_ids: Vec<i32> = follows.iter()
+            .map(|f| f.subject_actor_id)
+            .collect();
+
+        // Get profiles for all followed actors (with their post_rkeys)
+        let profiles = self.get_profiles_by_ids(&followed_actor_ids).await?;
+
+        // Convert to ProfileData which includes post_rkeys
+        let mut profiles_with_posts: Vec<ProfileData> = profiles.iter()
+            .map(ProfileData::from)
+            .collect();
+
+        // Optionally limit post_rkeys per user for performance
+        for profile in &mut profiles_with_posts {
+            profile.post_rkeys.truncate(max_posts_per_user);
+        }
+
+        Ok(profiles_with_posts)
+    }
+
+    /// Get posts for a specific author
+    /// Returns (actor_id, rkey) pairs for the author's posts
+    pub async fn get_author_posts(
+        &self,
+        actor_id: i32,
+        limit: usize,
+        cursor_rkey: Option<i64>,
+        filter: Option<&str>,
+    ) -> Result<Vec<(i32, i64)>> {
+        // Get the actor's profile (with post_rkeys)
+        let profile_data = match self.get_profile_by_id(actor_id).await {
+            Ok(actor) => ProfileData::from(&actor),
+            Err(_) => return Ok(Vec::new()),
+        };
+
+        let mut post_keys = Vec::new();
+
+        // Apply cursor filter if provided
+        for &rkey in &profile_data.post_rkeys {
+            if let Some(cursor) = cursor_rkey {
+                if rkey >= cursor {
+                    continue; // Skip posts at or after cursor
+                }
+            }
+
+            // TODO: Apply filter (posts_no_replies, posts_with_media, etc.)
+            // For now, return all posts
+            match filter {
+                Some("posts_no_replies") => {
+                    // Would need to check post type, for now include all
+                    post_keys.push((actor_id, rkey));
+                }
+                Some("posts_with_media") => {
+                    // Would need to check if post has media, for now include all
+                    post_keys.push((actor_id, rkey));
+                }
+                _ => {
+                    // Default: include all posts
+                    post_keys.push((actor_id, rkey));
+                }
+            }
+
+            if post_keys.len() >= limit {
+                break;
+            }
+        }
+
+        Ok(post_keys)
+    }
+
     // Note: Like-related methods are on PostEntity, not ProfileEntity
     // Likes are stored as arrays on the Post model (like_actor_ids, like_rkeys)
 
···
     pub followers_count: i32,
     pub following_count: i32,
     pub posts_count: i32,
+    pub post_rkeys: Vec<i64>,  // All post rkeys for this actor (sorted descending)
+    pub repost_rkeys: Vec<i64>,  // All repost rkeys for this actor (sorted descending)
 }
 
 impl From<&Actor> for ProfileData {
     fn from(actor: &Actor) -> Self {
+        // Extract and sort post rkeys (newest first)
+        let mut post_rkeys: Vec<i64> = actor.post_rkeys
+            .as_ref()
+            .map(|rkeys| {
+                rkeys.iter()
+                    .filter_map(|r| r.as_ref().copied())
+                    .collect()
+            })
+            .unwrap_or_default();
+        post_rkeys.sort_by(|a, b| b.cmp(a)); // Sort descending (newest first)
+
+        // Extract and sort repost rkeys (newest first)
+        let mut repost_rkeys: Vec<i64> = actor.repost_rkeys
+            .as_ref()
+            .map(|rkeys| {
+                rkeys.iter()
+                    .filter_map(|r| r.as_ref().copied())
+                    .collect()
+            })
+            .unwrap_or_default();
+        repost_rkeys.sort_by(|a, b| b.cmp(a)); // Sort descending (newest first)
+
         ProfileData {
             actor_id: actor.id,
             did: actor.did.clone(),
···
             followers_count: actor.followers_count.unwrap_or(0),
             following_count: actor.following_count.unwrap_or(0),
             posts_count: actor.posts_count.unwrap_or(0),
+            post_rkeys,
+            repost_rkeys,
         }
     }
 }

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

···
 use crate::xrpc::datetime_cursor;
-use crate::common::errors::{Error, XrpcResult};
+use crate::common::errors::XrpcResult;
 use crate::common::auth::{AtpAcceptLabelers, AtpAuth};
 use crate::GlobalState;
 use axum::extract::{Query, State};
 use axum::Json;
-use lexica::app_bsky::feed::{FeedReasonRepost, FeedViewPost, FeedViewPostReason, PostView};
+use lexica::app_bsky::feed::{FeedViewPost, PostView};
 use serde::{Deserialize, Serialize};
-use std::collections::HashMap;
 
 #[derive(Debug, Deserialize)]
 pub struct GetTimelineQuery {
···
     let user_actor_id = state.profile_entity.resolve_identifier(&user_did).await
         .map_err(|_| crate::common::errors::Error::actor_not_found(&user_did))?;
 
-    // Query database 
+    // New pattern: Get profiles with their posts, then hydrate
     let mut step_timer = std::time::Instant::now();
 
-    // Parse cursor
-    let cursor_value = datetime_cursor(query.cursor.as_ref());
+    // Parse cursor (convert to TID if provided)
+    let cursor_tid = query.cursor.as_ref()
+        .and_then(|c| datetime_cursor(Some(c)))
+        .map(|dt| {
+            let tid_str = parakeet_db::tid_util::timestamp_to_tid(dt);
+            parakeet_db::tid_util::decode_tid(&tid_str).unwrap_or(0)
+        });
 
-    // Get followed users from ProfileEntity
-    let following = state.profile_entity.get_following(user_actor_id, None, 255).await?;
-    let followed_ids: Vec<i32> = following.iter()
-        .map(|f| f.subject_actor_id)
-        .collect();
+    // Get followed profiles with their post rkeys (all cached)
+    let following_with_posts = state.profile_entity
+        .get_following_with_posts(user_actor_id, 255, 100)
+        .await?;
 
-    // Get timeline posts using PostEntity
-    let posts_result = state.post_entity.get_timeline_posts(&followed_ids, cursor_value.as_ref(), limit + 1).await
-        .map_err(|e| crate::common::errors::Error::server_error(Some(&e.to_string())))?;
+    let profile_fetch_time = step_timer.elapsed().as_secs_f64() * 1000.0;
+    tracing::info!("  ├─ Get following profiles with posts: {:.1} ms ({} profiles)",
+                   profile_fetch_time, following_with_posts.len());
+
+    step_timer = std::time::Instant::now();
+
+    // Collect timeline items (posts and reposts) from followed users
+    #[derive(Debug)]
+    enum TimelineItem {
+        Post { actor_id: i32, rkey: i64 },
+        Repost { reposter_id: i32, rkey: i64 },
+    }
+
+    let mut timeline_items: Vec<(i64, TimelineItem)> = Vec::new();
+
+    for profile in &following_with_posts {
+        // Add posts
+        for &rkey in &profile.post_rkeys {
+            // Apply cursor filtering if needed
+            if let Some(cursor) = cursor_tid {
+                if rkey >= cursor {
+                    continue; // Skip posts at or after cursor
+                }
+            }
+            timeline_items.push((rkey, TimelineItem::Post {
+                actor_id: profile.actor_id,
+                rkey
+            }));
+        }
+
+        // Add reposts
+        for &rkey in &profile.repost_rkeys {
+            // Apply cursor filtering if needed
+            if let Some(cursor) = cursor_tid {
+                if rkey >= cursor {
+                    continue; // Skip reposts at or after cursor
+                }
+            }
+            timeline_items.push((rkey, TimelineItem::Repost {
+                reposter_id: profile.actor_id,
+                rkey
+            }));
+        }
+    }
+
+    // Sort by rkey (TID) descending (newest first)
+    timeline_items.sort_by(|a, b| b.0.cmp(&a.0));
 
     // Check for next page
-    let has_next = posts_result.len() > limit as usize;
-    let posts_to_return = if has_next {
-        &posts_result[..limit as usize]
-    } else {
-        &posts_result[..]
-    };
+    let has_next = timeline_items.len() > limit as usize;
+    if has_next {
+        timeline_items.truncate(limit as usize + 1); // Keep one extra for cursor
+    }
 
-    // Convert to the expected format with optional reposter
-    let posts_with_reposter: Vec<(i32, i64, Option<i32>)> = posts_to_return
-        .iter()
-        .map(|(actor_id, rkey, _)| (*actor_id, *rkey, None))
-        .collect();
-
-    // Build cursor
-    let cursor = if has_next {
-        posts_result.get(limit as usize - 1).map(|(_, _, ts)| ts.timestamp_millis().to_string())
+    // Build cursor from last item (if we have more pages)
+    let cursor = if has_next && timeline_items.len() > limit as usize {
+        let last_rkey = timeline_items[limit as usize - 1].0;
+        let timestamp = parakeet_db::tid_util::tid_to_datetime(last_rkey);
+        Some(timestamp.timestamp_millis().to_string())
     } else {
         None
     };
 
-    // Create a result structure
-    struct TimelineResult {
-        posts_with_reposter: Vec<(i32, i64, Option<i32>)>,
-        cursor: Option<String>,
+    // Take only what we're returning
+    if has_next {
+        timeline_items.truncate(limit as usize);
     }
 
-    let result = TimelineResult {
-        posts_with_reposter,
-        cursor,
-    };
-    let db_time = step_timer.elapsed().as_secs_f64() * 1000.0;
-    tracing::info!("  ├─ Database query: {:.1} ms (returned {} posts)", db_time, result.posts_with_reposter.len());
+    let sort_time = step_timer.elapsed().as_secs_f64() * 1000.0;
+    tracing::info!("  ├─ Sort and filter timeline: {:.1} ms ({} items)", sort_time, timeline_items.len());
 
-    // Extract post URIs for caching
+    // Process timeline items (hydrate posts and reposts)
     step_timer = std::time::Instant::now();
-    let mut post_uris = Vec::new();
-    for (post_actor_id, post_rkey, _) in &result.posts_with_reposter {
-        // Build AT URI
-        let did = state.profile_entity.get_did_by_id(*post_actor_id).await
-            .unwrap_or_else(|_| format!("did:plc:unknown{}", post_actor_id));
-        post_uris.push(format!("at://{}/app.bsky.feed.post/{}", did, parakeet_db::tid_util::encode_tid(*post_rkey)));
-    }
 
+    // Build FeedViewPosts
+    let mut feed = Vec::new();
 
-    // Get posts with reply context using PostEntity
-    let mut posts_with_context = state.post_entity.get_by_uris_with_reply_context(post_uris.clone(), Some(&user_did)).await
-        .unwrap_or_default();
+    for (rkey, item) in timeline_items {
+        match item {
+            TimelineItem::Post { actor_id, rkey } => {
+                // Regular post - fetch and add to feed
+                if let Ok(Some(post_data)) = state.post_entity.get_post_by_key(actor_id, rkey).await {
+                    // Convert to PostView
+                    let post_views = state.post_entity.convert_to_post_views(vec![post_data.clone()], Some(&user_did)).await;
 
-    // Build feed with repost reasons
-    let mut feed = Vec::new();
-    for (i, uri) in post_uris.iter().enumerate() {
-        if let Some((post, reply_context)) = posts_with_context.remove(uri) {
-            let (_, _, reposter_actor_id) = &result.posts_with_reposter[i];
+                    if let Some(post_view) = post_views.into_iter().next() {
+                        // Build reply context if this is a reply
+                        let reply_context = state.post_entity.build_reply_context(&post_data, Some(&user_did)).await;
 
-            // Check if this is a repost
-            let reason = if let Some(reposter_id) = reposter_actor_id {
-                // Get reposter profile
-                if let Ok(reposter) = state.profile_entity.get_profile_by_id(*reposter_id).await {
-                    let reposter_view = state.profile_entity.actor_to_profile_view_basic(&reposter);
-                    Some(FeedViewPostReason::Repost(Box::new(FeedReasonRepost {
-                        by: reposter_view,
-                        uri: None, // TODO: Get actual repost URI
-                        cid: None, // TODO: Get actual repost CID
-                        indexed_at: chrono::Utc::now(), // TODO: Get actual repost time
-                    })))
-                } else {
-                    None
+                        feed.push(FeedViewPost {
+                            post: post_view,
+                            reply: reply_context,
+                            reason: None,
+                            feed_context: None,
+                        });
+                    }
                 }
-            } else {
-                None
-            };
+            }
+            TimelineItem::Repost { reposter_id, rkey } => {
+                // Repost - fetch the repost info, then the original post
+                if let Ok(Some((post_actor_id, post_rkey, indexed_at))) =
+                    state.post_entity.get_repost_info(reposter_id, rkey).await {
 
-            feed.push(FeedViewPost {
-                post,
-                reply: reply_context,
-                reason,
-                feed_context: None,
-            });
+                    // Fetch the original post being reposted
+                    if let Ok(Some(post_data)) = state.post_entity.get_post_by_key(post_actor_id, post_rkey).await {
+                        // Convert to PostView
+                        let post_views = state.post_entity.convert_to_post_views(vec![post_data.clone()], Some(&user_did)).await;
+
+                        if let Some(post_view) = post_views.into_iter().next() {
+                            // Get reposter's profile for the reason
+                            if let Ok(reposter) = state.profile_entity.get_profile_by_id(reposter_id).await {
+                                // Convert to ProfileViewBasic
+                                let reposter_basic = state.profile_entity.actor_to_profile_view_basic(&reposter);
+
+                                // Build the repost reason
+                                let reason = Some(lexica::app_bsky::feed::FeedViewPostReason::Repost(Box::new(
+                                    lexica::app_bsky::feed::FeedReasonRepost {
+                                        by: reposter_basic,
+                                        uri: Some(format!(
+                                            "at://{}/app.bsky.feed.repost/{}",
+                                            reposter.did,
+                                            parakeet_db::tid_util::encode_tid(rkey)
+                                        )),
+                                        cid: None, // TODO: Add CID if needed
+                                        indexed_at,
+                                    }
+                                )));
+
+                                // Build reply context if the reposted post is a reply
+                                let reply_context = state.post_entity.build_reply_context(&post_data, Some(&user_did)).await;
+
+                                feed.push(FeedViewPost {
+                                    post: post_view,
+                                    reply: reply_context,
+                                    reason,
+                                    feed_context: None,
+                                });
+                            }
+                        }
+                    }
+                }
+            }
         }
     }
 
···
     tracing::info!("  ├─ Hydrate feed posts: {:.1} ms", hydrate_time);
 
     let total_time = start.elapsed().as_secs_f64() * 1000.0;
-    tracing::info!("  └─ getTimeline total: {:.1} ms (returning {} posts, cursor: {:?})", total_time, feed.len(), result.cursor);
+    tracing::info!("  └─ getTimeline total: {:.1} ms (returning {} posts, cursor: {:?})", total_time, feed.len(), cursor);
 
     Ok(Json(GetTimelineRes {
-        cursor: result.cursor,
+        cursor,
         feed,
     }))
 }
···
     tracing::info!("getAuthorFeed: actor={}, filter={:?}, limit={}, cursor={:?}",
         query.actor, query.filter, limit, query.cursor);
 
-    // Resolve actor to actor_id using ProfileEntity
+    // Resolve actor to actor_id using ProfileEntity (only DID resolution here)
     let actor_id = state.profile_entity.resolve_identifier(&query.actor).await
         .map_err(|_| crate::common::errors::Error::actor_not_found(&query.actor))?;
 
-    // Parse cursor
-    let cursor_value = datetime_cursor(query.cursor.as_ref());
+    // Parse cursor (convert to TID if provided)
+    let cursor_tid = query.cursor.as_ref()
+        .and_then(|c| datetime_cursor(Some(c)))
+        .map(|dt| {
+            let tid_str = parakeet_db::tid_util::timestamp_to_tid(dt);
+            parakeet_db::tid_util::decode_tid(&tid_str).unwrap_or(0)
+        });
 
-    // Try cache first (for posts_no_replies filter only)
+    // Use ProfileEntity to get author's posts
     let mut step_timer = std::time::Instant::now();
-    if query.filter == Some("posts_no_replies".to_string()) {
-        if let Some(cached) = state.author_feed_cache.get(actor_id, "posts_no_replies", query.cursor.as_deref()).await {
-            let cache_time = step_timer.elapsed().as_secs_f64() * 1000.0;
-            tracing::info!("  ├─ Author feed cache hit: {:.1} ms", cache_time);
 
-            step_timer = std::time::Instant::now();
+    let post_keys = state.profile_entity
+        .get_author_posts(actor_id, limit as usize + 1, cursor_tid, query.filter.as_deref())
+        .await?;
 
-            // Get posts using PostEntity
-            let posts_map = state.post_entity.get_by_uris(cached.post_uris.clone(), viewer_did.as_deref()).await
-                .unwrap_or_default();
+    let profile_time = step_timer.elapsed().as_secs_f64() * 1000.0;
+    tracing::info!("  ├─ Get author posts: {:.1} ms ({} posts)", profile_time, post_keys.len());
 
-            // Convert to FeedViewPosts maintaining order
-            let mut feed = Vec::new();
-            for uri in cached.post_uris {
-                if let Some(post) = posts_map.get(&uri) {
-                    feed.push(FeedViewPost {
-                        post: post.clone(),
-                        reply: None,
-                        reason: None,
-                        feed_context: None,
-                    });
-                }
-            }
+    // Check for next page
+    let has_next = post_keys.len() > limit as usize;
+    let posts_to_return = if has_next {
+        &post_keys[..limit as usize]
+    } else {
+        &post_keys[..]
+    };
 
-            let hydrate_time = step_timer.elapsed().as_secs_f64() * 1000.0;
-            tracing::info!("  ├─ Hydrate cached author feed: {:.1} ms", hydrate_time);
-
-            let total_time = start.elapsed().as_secs_f64() * 1000.0;
-            tracing::info!("  └─ getAuthorFeed total (cache hit): {:.1} ms (returning {} posts)", total_time, feed.len());
-
-            return Ok(Json(GetAuthorFeedRes {
-                cursor: cached.cursor,
-                feed,
-            }));
-        }
-    }
+    // Build cursor from last post
+    let cursor = if has_next && posts_to_return.len() == limit as usize {
+        let last_rkey = posts_to_return[posts_to_return.len() - 1].1;
+        let timestamp = parakeet_db::tid_util::tid_to_datetime(last_rkey);
+        Some(timestamp.timestamp_millis().to_string())
+    } else {
+        None
+    };
 
-    // Cache miss or different filter - query database
+    // Hydrate posts using PostEntity (uses caching internally)
     step_timer = std::time::Instant::now();
-    // Use PostEntity's get_author_feed with filter
-    let posts = state.post_entity
-        .get_author_feed(actor_id, cursor_value.as_ref(), limit, query.filter.as_deref())
-        .await
-        .map_err(|e| Error::server_error(Some(&e.to_string())))?;
 
-    let db_time = step_timer.elapsed().as_secs_f64() * 1000.0;
-    tracing::info!("  ├─ Database query: {:.1} ms (returned {} posts)", db_time, posts.len());
+    let post_data_list = state.post_entity.get_posts_by_keys(posts_to_return).await
+        .unwrap_or_default();
 
-    // Build cursor from last post
-    let cursor = posts.last().map(|post| post.2.timestamp_millis().to_string());
+    // Get reply context if needed
+    let mut posts_with_reply: Vec<(PostView, Option<lexica::app_bsky::feed::ReplyRef>)> = Vec::new();
 
-    // Extract post URIs
-    let actor_did = state.profile_entity.get_did_by_id(actor_id).await
-        .unwrap_or_else(|_| format!("did:plc:unknown{}", actor_id));
+    for post_data in post_data_list {
+        // Convert to PostView
+        let post_views = state.post_entity.convert_to_post_views(vec![post_data.clone()], viewer_did.as_deref()).await;
 
-    let post_uris: Vec<String> = posts.iter().map(|(_, rkey, _)| {
-        format!("at://{}/app.bsky.feed.post/{}", actor_did, parakeet_db::tid_util::encode_tid(*rkey))
-    }).collect();
+        if let Some(post_view) = post_views.into_iter().next() {
+            // Build reply context if this is a reply
+            let reply_context = state.post_entity.build_reply_context(&post_data, viewer_did.as_deref()).await;
 
-    // Cache for posts_no_replies filter
-    if query.filter == Some("posts_no_replies".to_string()) && !post_uris.is_empty() {
-        state.author_feed_cache.set(
-            actor_id,
-            "posts_no_replies",
-            query.cursor.as_deref(),
-            post_uris.clone(),
-            cursor.clone(),
-        ).await;
+            posts_with_reply.push((post_view, reply_context));
+        }
     }
 
-    // Get posts with reply context using PostEntity
-    step_timer = std::time::Instant::now();
-    let mut posts_with_context = state.post_entity.get_by_uris_with_reply_context(post_uris.clone(), viewer_did.as_deref()).await
-        .unwrap_or_default();
+    let hydrate_time = step_timer.elapsed().as_secs_f64() * 1000.0;
+    tracing::info!("  ├─ Hydrate posts: {:.1} ms", hydrate_time);
 
-    // Convert to FeedViewPosts maintaining order
+    // Build feed
     let mut feed = Vec::new();
-    for uri in post_uris {
-        if let Some((post, reply_context)) = posts_with_context.remove(&uri) {
-            feed.push(FeedViewPost {
-                post,
-                reply: reply_context,
-                reason: None,
-                feed_context: None,
-            });
-        }
+    for (post, reply_context) in posts_with_reply {
+        feed.push(FeedViewPost {
+            post,
+            reply: reply_context,
+            reason: None,
+            feed_context: None,
+        });
     }
-
-    let hydrate_time = step_timer.elapsed().as_secs_f64() * 1000.0;
-    tracing::info!("  ├─ Hydrate author feed: {:.1} ms", hydrate_time);
 
     let total_time = start.elapsed().as_secs_f64() * 1000.0;
     tracing::info!("  └─ getAuthorFeed total: {:.1} ms (returning {} posts)", total_time, feed.len());