use serde::{Deserialize, Serialize};
use crate::lexicon::{extract_link_facets, Facet};
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ConvoMember {
pub did: String,
#[serde(default)]
pub handle: Option<String>,
#[serde(rename = "displayName", default)]
pub display_name: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MessageSender {
pub did: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct MessageView {
pub id: String,
#[serde(default)]
pub rev: String,
pub text: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub facets: Option<Vec<Facet>>,
pub sender: MessageSender,
#[serde(rename = "sentAt")]
pub sent_at: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct DeletedMessageView {
pub id: String,
#[serde(default)]
pub rev: String,
pub sender: MessageSender,
#[serde(rename = "sentAt")]
pub sent_at: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(tag = "$type")]
pub enum ChatMessageView {
#[serde(rename = "chat.bsky.convo.defs#messageView")]
Message(MessageView),
#[serde(rename = "chat.bsky.convo.defs#deletedMessageView")]
Deleted(DeletedMessageView),
#[serde(other)]
Unknown,
}
fn deserialize_optional_message_view<'de, D>(
deserializer: D,
) -> std::result::Result<Option<MessageView>, D::Error>
where
D: serde::Deserializer<'de>,
{
let raw: Option<serde_json::Value> = Option::deserialize(deserializer)?;
let Some(val) = raw else {
return Ok(None);
};
if val
.get("$type")
.and_then(serde_json::Value::as_str)
.is_some_and(|t| t.ends_with("#deletedMessageView"))
{
return Ok(None);
}
if val
.get("text")
.and_then(serde_json::Value::as_str)
.is_none()
{
return Ok(None);
}
Ok(serde_json::from_value::<MessageView>(val).ok())
}
fn deserialize_message_views_filtering_deleted<'de, D>(
deserializer: D,
) -> std::result::Result<Vec<MessageView>, D::Error>
where
D: serde::Deserializer<'de>,
{
let raw_items: Vec<serde_json::Value> = Vec::deserialize(deserializer)?;
let mut out = Vec::with_capacity(raw_items.len());
for val in raw_items {
if val
.get("$type")
.and_then(serde_json::Value::as_str)
.is_some_and(|t| t.ends_with("#deletedMessageView"))
{
continue;
}
if val
.get("text")
.and_then(serde_json::Value::as_str)
.is_none()
{
continue;
}
if let Ok(msg) = serde_json::from_value::<MessageView>(val) {
out.push(msg);
}
}
Ok(out)
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ConvoView {
pub id: String,
#[serde(default)]
pub rev: String,
#[serde(default)]
pub members: Vec<ConvoMember>,
#[serde(
rename = "lastMessage",
default,
deserialize_with = "deserialize_optional_message_view"
)]
pub last_message: Option<MessageView>,
#[serde(rename = "unreadCount", default)]
pub unread_count: u64,
#[serde(default)]
pub status: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListConvosResponse {
#[serde(default)]
pub convos: Vec<ConvoView>,
#[serde(default)]
pub cursor: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct ListConvoRequestsResponse {
#[serde(default)]
pub requests: Vec<ConvoView>,
#[serde(default)]
pub cursor: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct AcceptConvoRequest {
#[serde(rename = "convoId")]
pub convo_id: String,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct AcceptConvoResponse {
#[serde(default)]
pub rev: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct GetMessagesResponse {
#[serde(
default,
deserialize_with = "deserialize_message_views_filtering_deleted"
)]
pub messages: Vec<MessageView>,
#[serde(default)]
pub cursor: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SendMessagePayload {
pub text: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub facets: Option<Vec<Facet>>,
}
impl SendMessagePayload {
#[must_use]
pub fn new(text: impl Into<String>) -> Self {
let text = text.into();
let facets = extract_link_facets(&text);
Self {
text,
facets: if facets.is_empty() {
None
} else {
Some(facets)
},
}
}
#[must_use]
pub fn with_facets(text: impl Into<String>, facets: Option<Vec<Facet>>) -> Self {
Self {
text: text.into(),
facets,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct SendMessageRequest {
#[serde(rename = "convoId")]
pub convo_id: String,
pub message: SendMessagePayload,
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct UpdateReadRequest {
#[serde(rename = "convoId")]
pub convo_id: String,
#[serde(rename = "messageId")]
pub message_id: String,
}
#[cfg(test)]
#[allow(clippy::unwrap_used, clippy::expect_used, clippy::panic, missing_docs)]
mod tests {
use super::*;
use crate::lexicon::FacetFeature;
#[test]
fn test_send_message_payload_serialization() {
let payload_no_links = SendMessagePayload::new("Plain text message");
assert!(payload_no_links.facets.is_none());
let json_no_links = serde_json::to_value(&payload_no_links).unwrap();
assert_eq!(json_no_links["text"], "Plain text message");
assert!(json_no_links.get("facets").is_none());
let payload_with_link = SendMessagePayload::new("Visit https://example.com now");
assert!(payload_with_link.facets.is_some());
let json_with_link = serde_json::to_value(&payload_with_link).unwrap();
assert_eq!(json_with_link["text"], "Visit https://example.com now");
let facets = json_with_link["facets"].as_array().unwrap();
assert_eq!(facets.len(), 1);
assert_eq!(facets[0]["index"]["byteStart"], 6);
assert_eq!(facets[0]["index"]["byteEnd"], 25);
assert_eq!(
facets[0]["features"][0]["$type"],
"app.bsky.richtext.facet#link"
);
assert_eq!(facets[0]["features"][0]["uri"], "https://example.com");
}
#[test]
fn test_send_message_payload_deserialization() {
let json_str = r#"{
"text": "Hello https://test.org",
"facets": [
{
"index": { "byteStart": 6, "byteEnd": 22 },
"features": [
{ "$type": "app.bsky.richtext.facet#link", "uri": "https://test.org" }
]
}
]
}"#;
let payload: SendMessagePayload = serde_json::from_str(json_str).unwrap();
assert_eq!(payload.text, "Hello https://test.org");
let facets = payload.facets.unwrap();
assert_eq!(facets.len(), 1);
assert_eq!(facets[0].index.byte_start, 6);
assert_eq!(facets[0].index.byte_end, 22);
match &facets[0].features[0] {
FacetFeature::Link { uri } => assert_eq!(uri, "https://test.org"),
_ => panic!("expected Link"),
}
}
#[test]
fn test_convo_view_and_get_messages_survive_deleted_message_view() {
let convos_json = r#"{
"convos": [
{
"id": "convo-deleted-last",
"rev": "rev1",
"members": [{"did": "did:plc:alice"}],
"lastMessage": {
"$type": "chat.bsky.convo.defs#deletedMessageView",
"id": "msg-del-1",
"rev": "rev1",
"sender": {"did": "did:plc:alice"},
"sentAt": "2026-11-03T00:00:00Z"
},
"unreadCount": 0,
"status": "accepted"
},
{
"id": "convo-live-last",
"rev": "rev2",
"members": [{"did": "did:plc:bob"}],
"lastMessage": {
"$type": "chat.bsky.convo.defs#messageView",
"id": "msg-live-2",
"rev": "rev2",
"text": "!status",
"sender": {"did": "did:plc:bob"},
"sentAt": "2026-11-03T00:01:00Z"
},
"unreadCount": 1,
"status": "request"
}
]
}"#;
let parsed: ListConvosResponse = serde_json::from_str(convos_json).unwrap();
assert_eq!(parsed.convos.len(), 2);
assert!(parsed.convos[0].last_message.is_none());
assert_eq!(
parsed.convos[1].last_message.as_ref().unwrap().text,
"!status"
);
let messages_json = r#"{
"messages": [
{
"$type": "chat.bsky.convo.defs#deletedMessageView",
"id": "msg-del-1",
"rev": "rev1",
"sender": {"did": "did:plc:alice"},
"sentAt": "2026-11-03T00:00:00Z"
},
{
"$type": "chat.bsky.convo.defs#messageView",
"id": "msg-live-2",
"rev": "rev2",
"text": "hello bot",
"sender": {"did": "did:plc:bob"},
"sentAt": "2026-11-03T00:01:00Z"
}
]
}"#;
let msg_resp: GetMessagesResponse = serde_json::from_str(messages_json).unwrap();
assert_eq!(msg_resp.messages.len(), 1);
assert_eq!(msg_resp.messages[0].id, "msg-live-2");
assert_eq!(msg_resp.messages[0].text, "hello bot");
}
}