feat: denormalization strategy; feedgens

consumer/src/database_writer/bulk_processor.rs

···
             });
         } else if subject_uri.contains("/app.bsky.feed.generator/") {
             // Feedgen like - only include if feedgen exists (no auto-stubbing)
-            if let Some(&feedgen_id) = resolved_feedgens.get(subject_uri.as_str()) {
+            if let Some(&(feed_actor_id, ref feed_rkey)) = resolved_feedgens.get(subject_uri.as_str()) {
                 feedgen_like_data.push(FeedgenLikeCopyData {
                     actor_id,
                     rkey: like.rkey,
-                    feedgen_id,
+                    feed_actor_id,
+                    feed_rkey: feed_rkey.clone(),
                 });
             } else {
                 tracing::debug!(uri = %subject_uri, "Feedgen not found for like, skipping");

consumer/src/database_writer/bulk_types.rs

···
     pub via_repost_rkey: Option<i64>,    // Optional FK to reposts table (natural key part 2)
 }
 
-/// Data for bulk COPY into feedgen_likes table
+/// Data for bulk appending likes to feedgens.like_actor_ids[] arrays
 ///
-/// Maps to schema: feedgen_likes(actor_id, rkey, feedgen_id)
+/// Feedgen likes are stored as parallel arrays on feedgens table (like posts).
+/// Maps to: feedgens(like_actor_ids[], like_rkeys[])
 #[derive(Debug, Clone)]
 pub struct FeedgenLikeCopyData {
-    pub actor_id: i32,
-    pub rkey: i64,       // TID converted to i64
-    pub feedgen_id: i64, // Resolved FK to feedgens table
+    pub actor_id: i32,        // The liker's actor_id
+    pub rkey: i64,            // The like record's rkey (TID)
+    pub feed_actor_id: i32,   // Feedgen's actor_id (natural key part 1)
+    pub feed_rkey: String,    // Feedgen's rkey (natural key part 2)
 }
 
 /// Data for bulk COPY into labeler_likes table
···
     pub post_rkey: i64,
 }
 
-/// Result of inserting a feedgen like via bulk COPY
+/// Result of inserting a feedgen like via bulk array append
 #[derive(Debug)]
 pub struct InsertedFeedgenLike {
     /// The actor_id who liked the feedgen
     pub actor_id: i32,
-    /// The feedgen's synthetic ID
-    pub feedgen_id: i64,
+    /// The feedgen's actor_id (natural key part 1)
+    pub feed_actor_id: i32,
+    /// The feedgen's rkey (natural key part 2)
+    pub feed_rkey: String,
 }
 
 /// Result of inserting a labeler like via bulk COPY

consumer/src/database_writer/workers.rs

···
         match crate::db::bulk_copy::copy_feedgen_likes(&txn, bulk_ops.feedgen_likes).await {
             Ok(inserted) => {
                 total_inserted += inserted.len();
-
-                // Update feedgen like_count aggregates
-                let feedgen_ids: Vec<i64> = inserted.iter().map(|like| like.feedgen_id).collect();
-                if let Err(e) = crate::db::operations::increment_feedgen_like_counts(&txn, &feedgen_ids).await {
-                    tracing::error!(error = ?e, "Failed to update feedgen like_count aggregates");
-                }
-
+                // Note: like_count is maintained automatically by trigger (update_feedgen_like_count)
                 tracing::info!(inserted = inserted.len(), "Bulk COPY feedgen_likes completed");
             }
             Err(e) => {

consumer/src/db/bulk_copy/mod.rs

···
     Ok(result)
 }
 
-/// Bulk COPY feedgen likes into the database
+/// Bulk append feedgen likes to feedgens.like_actor_ids[] arrays
+///
+/// Feedgen likes are stored as parallel arrays on feedgens table (like posts).
+/// This function updates feedgens rows to append likes to their like_actor_ids[] and like_rkeys[] arrays.
 ///
-/// # Schema
+/// # Performance
 ///
-/// ```sql
-/// feedgen_likes(actor_id, rkey, feedgen_id)
-/// ```
+/// Groups likes by feedgen and uses single UPDATE per feedgen to append all likes at once.
 pub async fn copy_feedgen_likes(
     conn: &Transaction<'_>,
     likes: Vec<FeedgenLikeCopyData>,
···
         return Ok(Vec::new());
     }
 
-    tracing::debug!(count = likes.len(), "Starting bulk COPY for feedgen_likes");
+    tracing::debug!(count = likes.len(), "Starting bulk array append for feedgen likes");
     let start = std::time::Instant::now();
 
-    queries::create_feedgen_likes_staging_table(conn).await?;
+    // Group likes by feedgen (feed_actor_id, feed_rkey)
+    let mut likes_by_feedgen: std::collections::HashMap<(i32, String), Vec<(i32, i64)>> = std::collections::HashMap::new();
 
-    let copy_sink = conn
-        .copy_in(
-            "COPY feedgen_likes_staging (actor_id, rkey, feedgen_id)
-             FROM STDIN (FORMAT binary)",
-        )
-        .await?;
+    for like in &likes {
+        likes_by_feedgen
+            .entry((like.feed_actor_id, like.feed_rkey.clone()))
+            .or_default()
+            .push((like.actor_id, like.rkey));
+    }
 
-    let writer = BinaryCopyInWriter::new(
-        copy_sink,
-        &[
-            Type::INT4,  // actor_id
-            Type::INT8,  // rkey
-            Type::INT8,  // feedgen_id
-        ],
+    tracing::debug!(
+        feedgens_count = likes_by_feedgen.len(),
+        likes_count = likes.len(),
+        "Grouped likes by feedgen"
     );
 
-    futures::pin_mut!(writer);
+    // Update each feedgen to append likes to arrays
+    let mut updated_count = 0;
+    for ((feed_actor_id, feed_rkey), feedgen_likes) in likes_by_feedgen.iter() {
+        let liker_actor_ids: Vec<i32> = feedgen_likes.iter().map(|(aid, _)| *aid).collect();
+        let liker_rkeys: Vec<i64> = feedgen_likes.iter().map(|(_, rk)| *rk).collect();
 
-    for like in &likes {
-        writer
-            .as_mut()
-            .write(&[&like.actor_id, &like.rkey, &like.feedgen_id])
+        let rows = conn
+            .execute(
+                "UPDATE feedgens
+                 SET like_actor_ids = COALESCE(like_actor_ids, ARRAY[]::integer[]) || $3::integer[],
+                     like_rkeys = COALESCE(like_rkeys, ARRAY[]::bigint[]) || $4::bigint[]
+                 WHERE actor_id = $1 AND rkey = $2",
+                &[&feed_actor_id, &feed_rkey, &liker_actor_ids, &liker_rkeys],
+            )
             .await?;
-    }
 
-    writer.finish().await?;
-
-    let rows = conn
-        .query(
-            "WITH inserted AS (
-                 INSERT INTO feedgen_likes (actor_id, rkey, feedgen_id)
-                 SELECT actor_id, rkey, feedgen_id
-                 FROM feedgen_likes_staging
-                 ON CONFLICT (actor_id, rkey) DO NOTHING
-                 RETURNING actor_id, feedgen_id
-             )
-             SELECT
-                 i.actor_id,
-                 i.feedgen_id,
-                 'at://' || a.did || '/app.bsky.feed.generator/' || f.rkey as subject_uri
-             FROM inserted i
-             INNER JOIN feedgens f ON i.feedgen_id = f.id
-             INNER JOIN actors a ON f.actor_id = a.id",
-            &[],
-        )
-        .await?;
+        updated_count += rows;
+    }
 
-    let mut result = Vec::with_capacity(rows.len());
-    for row in rows {
-        let actor_id: i32 = row.get(0);
-        let feedgen_id: i64 = row.get(1);
+    tracing::debug!(updated_feedgens = updated_count, "Updated feedgens with likes");
 
+    // Build result
+    let mut result = Vec::with_capacity(likes.len());
+    for like in likes {
         result.push(InsertedFeedgenLike {
-            actor_id,
-            feedgen_id,
+            actor_id: like.actor_id,
+            feed_actor_id: like.feed_actor_id,
+            feed_rkey: like.feed_rkey,
         });
     }
 
     let elapsed = start.elapsed();
     tracing::info!(
-        count = likes.len(),
-        inserted = result.len(),
-        duplicates = likes.len() - result.len(),
+        count = result.len(),
+        feedgens_updated = updated_count,
         duration_ms = elapsed.as_millis(),
-        "Bulk COPY feedgen_likes completed"
+        "Bulk array append for feedgen_likes completed"
     );
 
     Ok(result)

consumer/src/db/bulk_resolve/mod.rs

···
     resolve_post_uris_bulk(conn, &uris).await
 }
 
-/// Resolve multiple feedgen AT-URIs to feedgen_ids in a single query
+/// Resolve multiple feedgen AT-URIs to natural keys
 ///
-/// Returns a HashMap of AT-URI → feedgen_id for all found feedgens.
+/// Returns a HashMap of AT-URI → (feed_actor_id, feed_rkey) for all found feedgens.
 /// Does NOT create stubs (feedgens must be explicitly created, not auto-stubbed).
 ///
 /// # Performance
 ///
-/// Single query joining actors and feedgens using `WHERE (a.did, f.rkey) = ANY(...)`.
+/// First resolves all DIDs to actor_ids in bulk, then queries feedgens by actor_id and rkey.
+///
+/// # Note
+///
+/// Phase 6 migration removed synthetic IDs - feedgens now use natural keys (actor_id, rkey).
+/// feedgen_likes table was dropped - likes are now stored as arrays on feedgens table.
 pub async fn resolve_feedgen_uris_bulk<C: GenericClient>(
     conn: &C,
     at_uris: &[&str],
-) -> Result<HashMap<String, i64>> {
+) -> Result<HashMap<String, (i32, String)>> {
     if at_uris.is_empty() {
         return Ok(HashMap::new());
     }
 
     // Parse URIs to extract (did, rkey) pairs
-    let mut did_rkey_pairs: Vec<(String, String)> = Vec::with_capacity(at_uris.len());
     let mut uri_to_did_rkey: HashMap<String, (String, String)> = HashMap::new();
+    let mut dids_set: std::collections::HashSet<String> = std::collections::HashSet::new();
 
     for uri in at_uris {
         let did = parakeet_db::at_uri_util::extract_did(uri)
···
         let rkey = parakeet_db::at_uri_util::extract_rkey(uri)
             .ok_or_else(|| eyre::eyre!("Invalid AT URI: missing rkey in {}", uri))?;
 
-        did_rkey_pairs.push((did.to_string(), rkey.to_string()));
         uri_to_did_rkey.insert(uri.to_string(), (did.to_string(), rkey.to_string()));
+        dids_set.insert(did.to_string());
     }
 
-    // Use UNNEST to create temporary table and join
-    let dids: Vec<String> = did_rkey_pairs.iter().map(|(d, _)| d.clone()).collect();
-    let rkeys: Vec<String> = did_rkey_pairs.iter().map(|(_, r)| r.clone()).collect();
+    // Resolve all actor DIDs to actor_ids (no auto-stubbing for feedgen owners)
+    let dids_vec: Vec<&str> = dids_set.iter().map(|s| s.as_str()).collect();
+    let did_to_actor_id = resolve_actor_dids_bulk(conn, &dids_vec).await?;
 
-    let rows = conn
-        .query(
-            "SELECT a.did, f.rkey, f.id
-             FROM actors a
-             INNER JOIN feedgens f ON f.actor_id = a.id
-             WHERE (a.did, f.rkey) IN (
-                 SELECT UNNEST($1::text[]), UNNEST($2::text[])
-             )",
-            &[&dids, &rkeys],
-        )
-        .await?;
+    // Collect rkeys for each actor_id
+    let mut actor_rkeys: Vec<(i32, String)> = Vec::new();
+    for (did, rkey) in uri_to_did_rkey.values() {
+        if let Some(&actor_id) = did_to_actor_id.get(did) {
+            actor_rkeys.push((actor_id, rkey.clone()));
+        }
+    }
 
-    // Build reverse mapping: (did, rkey) → feedgen_id
-    let mut did_rkey_to_id: HashMap<(String, String), i64> = HashMap::new();
+    if actor_rkeys.is_empty() {
+        return Ok(HashMap::new());
+    }
+
+    // Query feedgens existence by (actor_id, rkey) pairs
+    // Build dynamic query with OR clauses
+    let placeholders: Vec<String> = (0..actor_rkeys.len())
+        .map(|i| format!("(actor_id = ${} AND rkey = ${})", i * 2 + 1, i * 2 + 2))
+        .collect();
+    let query = format!(
+        "SELECT actor_id, rkey FROM feedgens WHERE {}",
+        placeholders.join(" OR ")
+    );
+
+    let mut params: Vec<&(dyn tokio_postgres::types::ToSql + Sync)> = Vec::new();
+    for (actor_id, rkey) in &actor_rkeys {
+        params.push(actor_id);
+        params.push(rkey);
+    }
+
+    let rows = conn.query(&query, &params).await?;
+
+    // Build reverse lookup: (actor_id, rkey) → natural key
+    let mut found_feedgens: std::collections::HashSet<(i32, String)> = std::collections::HashSet::new();
     for row in rows {
-        let did: String = row.get(0);
+        let actor_id: i32 = row.get(0);
         let rkey: String = row.get(1);
-        let feedgen_id: i64 = row.get(2);
-        did_rkey_to_id.insert((did, rkey), feedgen_id);
+        found_feedgens.insert((actor_id, rkey));
     }
 
-    // Map back to URIs
+    // Map URIs to natural keys (only for feedgens that exist)
     let mut result = HashMap::new();
     for (uri, (did, rkey)) in uri_to_did_rkey {
-        if let Some(&feedgen_id) = did_rkey_to_id.get(&(did, rkey)) {
-            result.insert(uri, feedgen_id);
+        if let Some(&actor_id) = did_to_actor_id.get(&did) {
+            if found_feedgens.contains(&(actor_id, rkey.clone())) {
+                result.insert(uri, (actor_id, rkey));
+            }
         }
     }
 
···
 /// # Performance
 ///
 /// Single query using `WHERE did = ANY($1)` to find labelers by their DID.
-/// Labelers are identified by having a record in the `labelers` table.
+/// Phase 2: Labelers are denormalized into actors table - identified by having labeler_status set.
 pub async fn resolve_labeler_dids_bulk<C: GenericClient>(
     conn: &C,
     dids: &[&str],
···
 
     let rows = conn
         .query(
-            "SELECT a.did, l.actor_id
-             FROM actors a
-             INNER JOIN labelers l ON l.actor_id = a.id
-             WHERE a.did = ANY($1)",
+            "SELECT did, id
+             FROM actors
+             WHERE did = ANY($1)
+               AND labeler_status IS NOT NULL",
             &[&dids],
         )
         .await?;

consumer/src/db/operations/feed.rs

···
 mod feedgen;
 
 // Re-export all public functions for external use
-pub use feedgen::{feedgen_delete, feedgen_upsert, increment_feedgen_like_counts, decrement_feedgen_like_count};
+pub use feedgen::{feedgen_delete, feedgen_upsert, decrement_feedgen_like_count};
 pub use helpers::{ensure_list_id, ensure_list_natural_key, get_actor_id};
 pub use like::{like_delete, like_insert, LikeSubject};
 pub use post::{post_delete, post_insert};

consumer/src/db/operations/feed/feedgen.rs

···
     .wrap_err_with(|| format!("Failed to delete feedgen for actor_id:{} rkey:{}", actor_id, rkey))
 }
 
-/// Increment like_count for multiple feedgens (bulk operation)
-///
-/// This is called after bulk inserting feedgen_likes to update the aggregate counts.
-/// Uses a single UPDATE statement with aggregation for efficiency.
-pub async fn increment_feedgen_like_counts<C: GenericClient>(
-    conn: &C,
-    feedgen_ids: &[i64],
-) -> Result<u64> {
-    if feedgen_ids.is_empty() {
-        return Ok(0);
-    }
-
-    conn.execute(
-        "UPDATE feedgens
-         SET like_count = like_count + counts.count
-         FROM (
-             SELECT id, COUNT(*) as count
-             FROM unnest($1::bigint[]) as id
-             GROUP BY id
-         ) AS counts
-         WHERE feedgens.id = counts.id",
-        &[&feedgen_ids],
-    )
-    .await
-    .wrap_err("Failed to increment feedgen like_count aggregates")
-}
+// NOTE: update_feedgen_like_counts() removed - like_count is now maintained automatically
+// by the update_feedgen_like_count() trigger (Phase 8 migration 2025-12-08-152125).
+// The trigger fires on INSERT or UPDATE OF like_actor_ids and sets like_count = array_length().
 
 /// Decrement like_count for a single feedgen
 ///

consumer/tests/feedgen_labeler_operations_test.rs

···
 //! Tests coverage for:
 //! - `feedgen_upsert` (insert and update paths)
 //! - `feedgen_delete`
-//! - `increment_feedgen_like_counts` (bulk increment aggregates)
+//! - Feedgen like_count trigger (automatic count maintenance from like_actor_ids array)
 //! - `decrement_feedgen_like_count` (single decrement with GREATEST protection)
 //! - `labeler_upsert` (creates labeler and maintains label definitions)
 //! - `labeler_delete`
···
 // ========================================
 
 #[tokio::test]
-async fn test_increment_feedgen_like_counts() -> eyre::Result<()> {
+async fn test_feedgen_like_count_trigger() -> eyre::Result<()> {
     let pool = test_pool();
     let mut conn = pool.get().await.wrap_err("Failed to get connection")?;
     let tx = conn
···
         .wrap_err("Failed to start transaction")?;
 
     // Create actors
+    let (liker1_actor_id, _, _) = consumer::db::operations::feed::get_actor_id(&tx, "did:plc:liker1")
+        .await
+        .wrap_err("Failed to ensure liker1 actor")?;
+    let (liker2_actor_id, _, _) = consumer::db::operations::feed::get_actor_id(&tx, "did:plc:liker2")
+        .await
+        .wrap_err("Failed to ensure liker2 actor")?;
+    let (liker3_actor_id, _, _) = consumer::db::operations::feed::get_actor_id(&tx, "did:plc:liker3")
+        .await
+        .wrap_err("Failed to ensure liker3 actor")?;
     consumer::db::operations::feed::get_actor_id(&tx, "did:plc:feedgenowner4")
         .await
         .wrap_err("Failed to ensure owner actor")?;
···
         .await
         .wrap_err("Failed to insert feedgen")?;
 
-    // Get feedgen_id
-    let feedgen_id: i64 = tx
-        .query_one(
-            "SELECT id FROM feedgens WHERE actor_id = $1 AND rkey = $2",
-            &[&owner_actor_id, &rkey],
-        )
-        .await
-        .wrap_err("Failed to get feedgen_id")?
-        .get(0);
-
     // Verify initial like_count is 0
     let initial_count: i32 = tx
         .query_one(
-            "SELECT like_count FROM feedgens WHERE id = $1",
-            &[&feedgen_id],
+            "SELECT like_count FROM feedgens WHERE actor_id = $1 AND rkey = $2",
+            &[&owner_actor_id, &rkey],
         )
         .await
         .wrap_err("Failed to get initial like_count")?
         .get(0);
     assert_eq!(initial_count, 0, "Initial like_count should be 0");
 
-    // Increment like count (simulating 3 likes for the same feedgen)
-    let result = feed::increment_feedgen_like_counts(&tx, &[feedgen_id, feedgen_id, feedgen_id])
-        .await
-        .wrap_err("Failed to increment feedgen like_counts")?;
-    assert_eq!(result, 1, "Should update 1 row (the feedgen itself)");
+    // Append likes to like_actor_ids array (simulating 3 likes)
+    // Trigger should automatically update like_count
+    tx.execute(
+        "UPDATE feedgens
+         SET like_actor_ids = ARRAY[$3, $4, $5]::integer[],
+             like_rkeys = ARRAY[1, 2, 3]::bigint[]
+         WHERE actor_id = $1 AND rkey = $2",
+        &[&owner_actor_id, &rkey, &liker1_actor_id, &liker2_actor_id, &liker3_actor_id],
+    )
+    .await
+    .wrap_err("Failed to update like arrays")?;
 
-    // Verify like_count was incremented
+    // Verify like_count was automatically updated by trigger
     let updated_count: i32 = tx
         .query_one(
-            "SELECT like_count FROM feedgens WHERE id = $1",
-            &[&feedgen_id],
+            "SELECT like_count FROM feedgens WHERE actor_id = $1 AND rkey = $2",
+            &[&owner_actor_id, &rkey],
         )
         .await
         .wrap_err("Failed to get updated like_count")?
         .get(0);
-    assert_eq!(updated_count, 3, "like_count should be incremented to 3");
+    assert_eq!(updated_count, 3, "like_count should be auto-updated to 3 by trigger");
 
     tx.rollback().await.wrap_err("Failed to rollback")?;
     Ok(())

migrations/2025-12-08-152125_fix_feedgen_likes_natural_keys/down.sql

···
+-- Revert feedgen likes denormalization
+--
+-- Note: This down migration cannot restore the data since we dropped the table.
+
+-- Step 1: Drop trigger and function
+DROP TRIGGER IF EXISTS feedgen_like_count_trigger ON feedgens;
+DROP FUNCTION IF EXISTS update_feedgen_like_count();
+
+-- Step 2: Drop GIN index
+DROP INDEX IF EXISTS idx_feedgens_like_actor_ids_gin;
+
+-- Step 2: Recreate feedgen_likes table (with orphaned feedgen_id)
+CREATE TABLE feedgen_likes (
+  actor_id INTEGER NOT NULL,
+  rkey BIGINT NOT NULL,
+  feedgen_id BIGINT NOT NULL,
+  PRIMARY KEY (actor_id, rkey)
+);
+
+CREATE INDEX idx_feedgen_likes_feedgen ON feedgen_likes(feedgen_id);
+CREATE INDEX idx_feedgen_likes_rkey ON feedgen_likes(rkey);
+
+-- Step 3: Drop like array columns from feedgens
+ALTER TABLE feedgens DROP COLUMN IF EXISTS like_actor_ids;
+ALTER TABLE feedgens DROP COLUMN IF EXISTS like_rkeys;

migrations/2025-12-08-152125_fix_feedgen_likes_natural_keys/up.sql

···
+-- Denormalize feedgen likes into feedgens table
+--
+-- This follows the same pattern as posts (Phase 1) where likes are stored as parallel arrays.
+-- The feedgen_likes table is dropped and replaced with like arrays on feedgens.
+
+-- Step 1: Add like array columns to feedgens
+ALTER TABLE feedgens
+  ADD COLUMN like_actor_ids INTEGER[],
+  ADD COLUMN like_rkeys BIGINT[];
+
+-- Step 2: Backfill like arrays from feedgen_likes table
+-- Since feedgens.id was dropped but feedgen_likes.feedgen_id still references it,
+-- we can't join properly. The data is orphaned, so we'll truncate and start fresh.
+-- In production, you would need to reconstruct the joins or manually fix the data.
+
+-- For now, just drop the broken table
+DROP TABLE feedgen_likes;
+
+-- Step 3: Add GIN indexes for array operations (matching posts pattern)
+CREATE INDEX idx_feedgens_like_actor_ids_gin ON feedgens USING gin (like_actor_ids gin__int_ops);
+
+-- Step 4: Add trigger to maintain like_count automatically from like_actor_ids array
+-- Note: like_count column already exists from migration 2025-11-27-143034
+CREATE OR REPLACE FUNCTION update_feedgen_like_count()
+RETURNS TRIGGER AS $$
+BEGIN
+  NEW.like_count := COALESCE(array_length(NEW.like_actor_ids, 1), 0);
+  RETURN NEW;
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE TRIGGER feedgen_like_count_trigger
+  BEFORE INSERT OR UPDATE OF like_actor_ids ON feedgens
+  FOR EACH ROW
+  EXECUTE FUNCTION update_feedgen_like_count();

parakeet-db/src/models.rs

···
 // SOCIAL INTERACTIONS
 // =============================================================================
 
-// Feed Generator Likes (rare, ~0.01% of likes)
-#[derive(Clone, Debug, Queryable, Selectable, Identifiable)]
-#[diesel(table_name = crate::schema::feedgen_likes)]
-#[diesel(primary_key(actor_id, rkey))]
-#[diesel(check_for_backend(diesel::pg::Pg))]
-pub struct FeedgenLike {
-    pub actor_id: i32,   // PK: FK to actors
-    pub rkey: i64,       // PK: TID as INT8
-    pub feedgen_id: i64, // FK to feedgens (enforced by database!)
-                         // Note: created_at derived from TID rkey via created_at() method
-}
+// Note: Feed Generator Likes table dropped - likes stored as arrays on feedgens table
+// The like_actor_ids[] and like_rkeys[] arrays are maintained on feedgens
+// This follows the same denormalization pattern as posts
 
 // Note: Labeler Likes table dropped - labeler data moved to actors table
 // The labeler_like_count is maintained on actors.labeler_like_count
···
 // Implement HasTidRkey for all models with TID-based rkeys
 
 impl_tid_rkey!(Post);
-impl_tid_rkey!(FeedgenLike);
+// impl_tid_rkey!(FeedgenLike); // Removed - feedgen_likes table dropped, now like_actor_ids[]/like_rkeys[] arrays
 // impl_tid_rkey!(LabelerLike); // Removed - labeler_likes table dropped
 impl_tid_rkey!(Repost);
 // impl_tid_rkey!(Follow); // Removed - follows table dropped, now follow_record[] arrays
···
 // This eliminates the need for a separate created_at column in the database
 
 impl_tid_created_at!(Post);
-impl_tid_created_at!(FeedgenLike);
+// impl_tid_created_at!(FeedgenLike); // Removed - feedgen_likes table dropped, now like_actor_ids[]/like_rkeys[] arrays
 // impl_tid_created_at!(LabelerLike); // Removed - labeler_likes table dropped
 impl_tid_created_at!(Repost);
 // impl_tid_created_at!(Follow); // Removed - follows table dropped, now follow_record[] arrays

parakeet-db/src/schema.rs

···
 }
 
 diesel::table! {
-    feedgen_likes (actor_id, rkey) {
-        actor_id -> Int4,
-        rkey -> Int8,
-        feedgen_id -> Int8,
-    }
-}
-
-diesel::table! {
     use diesel::sql_types::*;
     use super::sql_types::ContentMode;
     use super::sql_types::FeedgenStatus;
···
         accepts_interactions -> Bool,
         status -> FeedgenStatus,
         like_count -> Int4,
+        like_actor_ids -> Nullable<Array<Nullable<Int4>>>,
+        like_rkeys -> Nullable<Array<Nullable<Int8>>>,
     }
 }
 
···
     actors,
     backfill_jobs,
     constellation_enrichment_queue,
-    feedgen_likes,
     feedgens,
     fetch_queue,
     handle_resolution_queue,