feat: denormalize strategy; labels to arrays

migrations/2025-12-08-033410_labels_to_arrays/down.sql

···
+-- Rollback Phase 7: Restore labels table from arrays
+
+-- Recreate labels table
+CREATE TABLE labels (
+    labeler_actor_id INTEGER NOT NULL,
+    label TEXT NOT NULL,
+    uri TEXT NOT NULL,
+    self_label BOOLEAN NOT NULL DEFAULT false,
+    cid BYTEA,
+    negated BOOLEAN NOT NULL DEFAULT false,
+    expires TIMESTAMP WITH TIME ZONE,
+    sig BYTEA,
+    created_at TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT now(),
+    PRIMARY KEY (labeler_actor_id, label, uri)
+);
+
+-- Recreate indexes
+CREATE INDEX idx_labels_uri ON labels(uri);
+CREATE INDEX idx_labels_expires ON labels(expires) WHERE expires IS NOT NULL;
+
+-- Backfill post labels
+INSERT INTO labels (labeler_actor_id, label, uri, self_label, negated, expires, created_at)
+SELECT
+    (label_data).labeler_actor_id,
+    (label_data).label,
+    'at://' || a.did || '/app.bsky.feed.post/' || i64_to_tid(p.rkey),
+    false,  -- self_label - not stored in composite type
+    (label_data).negated,
+    (label_data).expires,
+    (label_data).created_at
+FROM posts p
+INNER JOIN actors a ON p.actor_id = a.id
+CROSS JOIN LATERAL UNNEST(p.labels) AS label_data
+WHERE p.labels IS NOT NULL;
+
+-- Backfill actor labels
+INSERT INTO labels (labeler_actor_id, label, uri, self_label, negated, expires, created_at)
+SELECT
+    (label_data).labeler_actor_id,
+    (label_data).label,
+    'at://' || a.did || '/app.bsky.actor.profile/self',
+    false,  -- self_label - not stored in composite type
+    (label_data).negated,
+    (label_data).expires,
+    (label_data).created_at
+FROM actors a
+CROSS JOIN LATERAL UNNEST(a.labels) AS label_data
+WHERE a.labels IS NOT NULL;
+
+-- Drop GIN indexes
+DROP INDEX idx_posts_labels_gin;
+DROP INDEX idx_actors_labels_gin;
+
+-- Drop label columns
+ALTER TABLE posts DROP COLUMN labels;
+ALTER TABLE actors DROP COLUMN labels;

migrations/2025-12-08-033410_labels_to_arrays/up.sql

···
+-- Phase 7: Denormalize Labels into Arrays
+--
+-- This migration:
+-- 1. Adds labels arrays to posts and actors tables
+-- 2. Backfills labels from the labels table
+-- 3. Drops the labels table
+--
+-- Labels are stored as composite types (post_label, actor_label) in arrays
+
+-- Step 1: Add labels columns
+ALTER TABLE posts ADD COLUMN labels post_label[];
+ALTER TABLE actors ADD COLUMN labels actor_label[];
+
+-- Step 2: Backfill posts labels
+-- Join labels table with actors to get DIDs, then construct AT URIs for posts
+UPDATE posts p
+SET labels = (
+  SELECT ARRAY_AGG(
+    ROW(
+      l.labeler_actor_id,
+      l.label,
+      l.created_at,
+      l.negated,
+      l.expires
+    )::post_label
+    ORDER BY l.created_at
+  )
+  FROM labels l
+  INNER JOIN actors a ON p.actor_id = a.id
+  WHERE l.uri = 'at://' || a.did || '/app.bsky.feed.post/' || i64_to_tid(p.rkey)
+);
+
+-- Step 3: Backfill actors labels
+-- Note: Actor labels use the profile record URI: at://{did}/app.bsky.actor.profile/self
+UPDATE actors a
+SET labels = (
+  SELECT ARRAY_AGG(
+    ROW(
+      l.labeler_actor_id,
+      l.label,
+      l.created_at,
+      l.negated,
+      l.expires
+    )::actor_label
+    ORDER BY l.created_at
+  )
+  FROM labels l
+  WHERE l.uri = 'at://' || a.did || '/app.bsky.actor.profile/self'
+);
+
+-- Step 4: Create GIN indexes for fast array searches
+CREATE INDEX idx_posts_labels_gin ON posts USING GIN (labels);
+CREATE INDEX idx_actors_labels_gin ON actors USING GIN (labels);
+
+-- Step 5: Drop old labels table
+DROP TABLE labels;

parakeet-db/src/composite_types.rs

···
     LabelerDefRecord, FollowRecord,
     MuteRecord, BlockRecord, BookmarkRecord,  // Phase 4: User preferences (diesel-generated)
     ThreadMuteRecord, ListMuteRecord, ListBlockRecord,  // Phase 5: List moderation (diesel-generated)
+    PostLabel, ActorLabel,  // Phase 7: Label composite types (diesel-generated)
 };
-
-// Placeholder SQL types for composite types not yet used in tables
-// NOTE: Once columns are added with these composite types, diesel will auto-generate the SQL types
-#[allow(dead_code)]
-mod placeholder_sql_types {
-    use diesel::query_builder::QueryId;
-    use diesel::sql_types::SqlType;
-
-    // Phase 7: Label composite types (will be added later)
-    #[derive(QueryId, SqlType)]
-    #[diesel(postgres_type(name = "post_label"))]
-    pub struct PostLabel;
-
-    #[derive(QueryId, SqlType)]
-    #[diesel(postgres_type(name = "actor_label"))]
-    pub struct ActorLabel;
-}
-
-use placeholder_sql_types::*;
 use crate::types::{
     ImageMimeType, VideoMimeType, FacetType, CaptionMimeType, LanguageCode,
-    LabelSeverity, LabelBlurs, LabelDefaultSetting,
+    LabelSeverity, LabelBlurs, LabelDefaultSetting,  // For labeler_def_record
 };
 use chrono::{DateTime, Utc};
 use diesel::deserialize::{self, FromSql};

parakeet-db/src/models.rs

···
     // Phase 6: RKey arrays for quick lookups
     pub post_rkeys: Option<Vec<Option<i64>>>,   // All post rkeys owned by this actor
     pub repost_rkeys: Option<Vec<Option<i64>>>, // All repost rkeys owned by this actor
+    // Phase 7: Labels array (from labels table, denormalized)
+    pub labels: Option<Vec<Option<crate::composite_types::ActorLabelRecord>>>, // Labels applied to this actor
 }
 
 // AllowlistEntry model removed - allowlist table dropped in favor of actors.sync_state
···
     pub postgate_rules: Option<array_helpers::PostgateRuleArray>,    // Rules (maxLength: 5)
     pub postgate_detached_actor_ids: Option<Vec<Option<i32>>>,       // Detached embed authors (maxLength: 50)
     pub postgate_detached_rkeys: Option<Vec<Option<i64>>>,           // Detached embed rkeys (parallel array)
+    // Phase 7: Labels array (from labels table, denormalized)
+    pub labels: Option<Vec<Option<crate::composite_types::PostLabelRecord>>>, // Labels applied to this post
                                                     // Note: created_at derived from TID rkey via created_at() method
 }
 

parakeet-db/src/schema.rs

···
 
 pub mod sql_types {
     #[derive(diesel::query_builder::QueryId, diesel::sql_types::SqlType)]
+    #[diesel(postgres_type(name = "actor_label"))]
+    pub struct ActorLabel;
+
+    #[derive(diesel::query_builder::QueryId, diesel::sql_types::SqlType)]
     #[diesel(postgres_type(name = "actor_status"))]
     pub struct ActorStatus;
 
···
     pub struct PostImageEmbed;
 
     #[derive(diesel::query_builder::QueryId, diesel::sql_types::SqlType)]
+    #[diesel(postgres_type(name = "post_label"))]
+    pub struct PostLabel;
+
+    #[derive(diesel::query_builder::QueryId, diesel::sql_types::SqlType)]
     #[diesel(postgres_type(name = "post_stat_type"))]
     pub struct PostStatType;
 
···
     use super::sql_types::ThreadMuteRecord;
     use super::sql_types::ListMuteRecord;
     use super::sql_types::ListBlockRecord;
+    use super::sql_types::ActorLabel;
 
     actors (id) {
         id -> Int4,
···
         list_blocks -> Nullable<Array<Nullable<ListBlockRecord>>>,
         post_rkeys -> Nullable<Array<Nullable<Int8>>>,
         repost_rkeys -> Nullable<Array<Nullable<Int8>>>,
+        labels -> Nullable<Array<Nullable<ActorLabel>>>,
     }
 }
 
···
 }
 
 diesel::table! {
-    labels (labeler_actor_id, label, uri) {
-        labeler_actor_id -> Int4,
-        label -> Text,
-        uri -> Text,
-        self_label -> Bool,
-        cid -> Nullable<Bytea>,
-        negated -> Bool,
-        expires -> Nullable<Timestamptz>,
-        sig -> Nullable<Bytea>,
-        created_at -> Timestamptz,
-    }
-}
-
-diesel::table! {
     list_items (actor_id, rkey) {
         actor_id -> Int4,
         rkey -> Int8,
···
     use super::sql_types::PostFacetEmbed;
     use super::sql_types::ThreadgateRule;
     use super::sql_types::PostgateRule;
+    use super::sql_types::PostLabel;
 
     posts (actor_id, rkey) {
         actor_id -> Int4,
···
         postgate_rules -> Nullable<Array<Nullable<PostgateRule>>>,
         postgate_detached_actor_ids -> Nullable<Array<Nullable<Int4>>>,
         postgate_detached_rkeys -> Nullable<Array<Nullable<Int8>>>,
+        labels -> Nullable<Array<Nullable<PostLabel>>>,
     }
 }
 
···
     fetch_queue,
     handle_resolution_queue,
     jetstream_cursors,
-    labels,
     list_items,
     lists,
     notifications,

parakeet-db/src/types.rs

···
     Chat = "chat",
 });
 
+// Label configuration enums (used in labeler_def_record composite type)
+// Note: These are different from label instance data (post_label, actor_label)
 diesel_enum!(LabelSeverity, LabelSeverity, {
     Inform = "inform",
     Alert = "alert",

parakeet/src/loaders/post.rs

···
                     postgate_rules: None,
                     postgate_detached_actor_ids: None,
                     postgate_detached_rkeys: None,
+                    // Phase 7: Labels (not loaded for hydration - will be loaded separately if needed)
+                    labels: None,
                 };
 
                 // Encode TIDs using Rust utility functions