fix!: labeler subjectTypes and subjectCollections

consumer/src/indexer/db.rs

···
         .reason_types
         .as_ref()
         .map(|v| v.iter().map(|v| v.to_string()).collect());
+    let subject_types = rec
+        .subject_types
+        .as_ref()
+        .map(|v| v.iter().map(|v| v.to_string()).collect());
 
     let data = models::UpsertLabelerService {
         did: repo,
         cid: cid.to_string(),
         reasons,
+        subject_types,
+        subject_collections: rec.subject_collections.as_ref(),
         indexed_at: Utc::now().naive_utc(),
     };
 

lexica/src/com_atproto/moderation.rs

···
     Record,
     Chat,
 }
+
+impl Display for SubjectType {
+    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SubjectType::Account => write!(f, "account"),
+            SubjectType::Record => write!(f, "record"),
+            SubjectType::Chat => write!(f, "chat"),
+        }
+    }
+}
+
+impl FromStr for SubjectType {
+    type Err = String;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "account" => Ok(SubjectType::Account),
+            "record" => Ok(SubjectType::Record),
+            "chat" => Ok(SubjectType::Chat),
+            x => Err(format!("Unrecognized variant {}", x)),
+        }
+    }
+}

migrations/2025-04-11-155301_labels/up.sql

···
 create table labelers
 (
-    did        text primary key references actors (did) on delete cascade,
-    cid        text      not null,
+    did                 text primary key references actors (did) on delete cascade,
+    cid                 text      not null,
 
-    reasons    text[],
+    reasons             text[],
+    subject_types       text[],
+    subject_collections text[],
 
-    created_at timestamp not null default now(),
-    indexed_at timestamp not null default now()
+    created_at          timestamp not null default now(),
+    indexed_at          timestamp not null default now()
 );
 
 create table labeler_defs

parakeet-db/src/models.rs

···
     pub cid: String,
 
     pub reasons: Option<Vec<Option<String>>>,
+    pub subject_types: Option<Vec<Option<String>>>,
+    pub subject_collections: Option<Vec<Option<String>>>,
 
     pub created_at: NaiveDateTime,
     pub indexed_at: NaiveDateTime,
···
     pub cid: String,
 
     pub reasons: Option<Vec<String>>,
+    pub subject_types: Option<Vec<String>>,
+    pub subject_collections: Option<&'a Vec<String>>,
 
     pub indexed_at: NaiveDateTime,
 }

parakeet-db/src/schema.rs

···
         did -> Text,
         cid -> Text,
         reasons -> Nullable<Array<Nullable<Text>>>,
+        subject_types -> Nullable<Array<Nullable<Text>>>,
+        subject_collections -> Nullable<Array<Nullable<Text>>>,
         created_at -> Timestamp,
         indexed_at -> Timestamp,
     }

parakeet/src/hydration/labeler.rs

···
 use lexica::app_bsky::actor::ProfileView;
 use lexica::app_bsky::labeler::{LabelerPolicy, LabelerView, LabelerViewDetailed};
 use lexica::com_atproto::label::{Blurs, LabelValueDefinition, Severity};
-use lexica::com_atproto::moderation::ReasonType;
+use lexica::com_atproto::moderation::{ReasonType, SubjectType};
 use parakeet_db::models;
 use std::collections::HashMap;
 use std::str::FromStr;
···
             })
         })
         .collect();
+    let subject_types = labeler.subject_types.map(|v| {
+        v.into_iter()
+            .flatten()
+            .filter_map(|v| SubjectType::from_str(&v).ok())
+            .collect()
+    });
+    let subject_collections = labeler
+        .subject_collections
+        .map(|v| v.into_iter().flatten().collect());
 
     LabelerViewDetailed {
         uri: format!("at://{}/app.bsky.labeler.service/self", labeler.did),
···
             label_value_definitions,
         },
         reason_types,
-        subject_types: None,
-        subject_collections: None,
+        subject_types,
+        subject_collections,
         labels: map_labels(labels),
         indexed_at: labeler.indexed_at,
     }