fix: cursors, list uris

parakeet/src/entities/core/list.rs

···
         list_rkey: &str,
         cursor: Option<&chrono::DateTime<chrono::Utc>>,
         limit: u8,
-    ) -> eyre::Result<Vec<(i32, chrono::DateTime<chrono::Utc>)>> {
+    ) -> eyre::Result<Vec<(i32, i32, i64, chrono::DateTime<chrono::Utc>)>> {
         let mut conn = self.db_pool.get().await?;
 
         use diesel::sql_types::{BigInt, Integer, Text};
···
         #[derive(diesel::QueryableByName)]
         struct ItemRow {
             #[diesel(sql_type = Integer)]
-            subject_actor_id: i32,
+            actor_id: i32,
             #[diesel(sql_type = BigInt)]
             rkey: i64,
+            #[diesel(sql_type = Integer)]
+            subject_actor_id: i32,
         }
 
         // Simple query - just get the data we need
         let results: Vec<ItemRow> = diesel::sql_query(
             r#"
             SELECT
-                subject_actor_id,
-                rkey
+                actor_id,
+                rkey,
+                subject_actor_id
             FROM list_items
             WHERE list_owner_actor_id = $1
               AND list_rkey = $2
···
                 }
             }
 
-            processed.push((row.subject_actor_id, created_at));
+            processed.push((row.actor_id, row.subject_actor_id, row.rkey, created_at));
 
             if processed.len() >= limit as usize {
                 break;

parakeet/src/entities/core/post.rs

···
 
         // Extract text from content if available
         let text = if let Some(ref content_bytes) = data.post.content {
-            // Content is zstd compressed
+            // Content is zstd compressed plain text
             // Create a codec and decompress the content
             let codec = parakeet_db::compression::PostContentCodec::new();
-            if let Ok(decompressed_str) = codec.decompress(content_bytes.as_slice()) {
-                if let Ok(record) = serde_json::from_str::<serde_json::Value>(&decompressed_str) {
-                    record.get("text")
-                        .and_then(|t| t.as_str())
-                        .map(|s| s.to_string())
-                        .unwrap_or_default()
-                } else {
-                    String::new()
-                }
-            } else {
-                String::new()
-            }
+            codec.decompress(content_bytes.as_slice()).unwrap_or_default()
         } else {
             String::new()
         };

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

···
     State(state): State<GlobalState>,
     AtpAcceptLabelers(_labelers): AtpAcceptLabelers,
     maybe_auth: Option<AtpAuth>,
-    Query(query): Query<GetFeedGeneratorsQuery>,
+    axum_extra::extract::Query(query): axum_extra::extract::Query<GetFeedGeneratorsQuery>,
 ) -> XrpcResult<Json<GetFeedGeneratorsRes>> {
     // Get viewer DID if authenticated
     let viewer_did = maybe_auth.as_ref().map(|auth| auth.0.clone());

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

···
     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())
+        Some(timestamp.to_rfc3339())
     } else {
         None
     };
···
     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())
+        Some(timestamp.to_rfc3339())
     } else {
         None
     };

parakeet/src/xrpc/app_bsky/graph/lists.rs

···
     // Calculate next cursor
     let cursor = item_results
         .last()
-        .map(|item| item.1.to_rfc3339());
+        .map(|item| item.3.to_rfc3339());
 
     // Get profiles for all subject actor IDs
     let subject_ids: Vec<i32> = item_results
         .iter()
-        .map(|item| item.0)
+        .map(|item| item.1) // subject_actor_id
+        .collect();
+
+    // Also get DIDs for list item actors
+    let item_actor_ids: Vec<i32> = item_results
+        .iter()
+        .map(|item| item.0) // actor_id
         .collect();
 
     // Get the actual actor profiles
     let profiles = state.profile_entity.get_profile_views(&subject_ids).await;
 
+    // Get DIDs for list item actors
+    let mut item_actor_dids = std::collections::HashMap::new();
+    for actor_id in &item_actor_ids {
+        if let Ok(did) = state.profile_entity.get_did_by_id(*actor_id).await {
+            item_actor_dids.insert(*actor_id, did);
+        }
+    }
+
     // Map actor_id to ProfileView
     let mut actor_views = std::collections::HashMap::new();
     for (idx, profile) in profiles.into_iter().enumerate() {
···
     // Build ListItemViews
     let items: Vec<ListItemView> = item_results
         .into_iter()
-        .filter_map(|(subject_actor_id, _created_at)| {
+        .filter_map(|(actor_id, subject_actor_id, rkey, _created_at)| {
             let subject = actor_views.get(&subject_actor_id).cloned()?;
+            let item_did = item_actor_dids.get(&actor_id)?;
 
-            // TODO: Construct proper item URI
-            let item_uri = format!("at://unknown/app.bsky.graph.listitem/unknown");
+            // Construct proper item URI
+            let item_uri = format!(
+                "at://{}/app.bsky.graph.listitem/{}",
+                item_did,
+                parakeet_db::tid_util::encode_tid(rkey)
+            );
 
             Some(ListItemView {
                 uri: item_uri,

parakeet/src/xrpc/app_bsky/mod.rs

···
         .route("/app.bsky.bookmark.getBookmarks", get(bookmark::get_bookmarks))
         .route("/app.bsky.feed.getActorFeeds", get(feed::feedgen::get_actor_feeds))
         .route("/app.bsky.feed.getActorLikes", get(feed::likes::get_actor_likes))
-        .route("/app.bsky.feed.getAuthorFeed", get(feed::posts::get_author_feed))
+        .route("/app.bsky.feed.getAuthorFeed", get(feed::get_timeline::get_author_feed))
         .route("/app.bsky.feed.getFeed", get(feed::posts::get_feed))
         .route("/app.bsky.feed.getFeedGenerator", get(feed::feedgen::get_feed_generator))
         .route("/app.bsky.feed.getFeedGenerators", get(feed::feedgen::get_feed_generators))