imessage-serializers 0.1.0

Entity-to-JSON serializers for imessage-rs chat, message, handle, and attachment models.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146

/// Chat serializer — converts a Chat entity to the API JSON shape.
///
/// Full response (non-notification):
/// {
///     "originalROWID": 1,
///     "guid": "iMessage;-;+15551234567",
///     "style": 45,
///     "chatIdentifier": "+15551234567",
///     "isArchived": false,
///     "displayName": null,
///     "participants": [...],
///     "isFiltered": false,
///     "groupId": "...",
///     "properties": null,
///     "lastAddressedHandle": null
/// }
use serde_json::{Map, Value, json};

use imessage_db::imessage::entities::Chat;

use crate::config::ChatSerializerConfig;
use crate::handle::serialize_handles;
use crate::plist_decode;

/// Serialize a single Chat to JSON.
pub fn serialize_chat(
    chat: &Chat,
    config: &ChatSerializerConfig,
    is_for_notification: bool,
) -> Value {
    let mut map = Map::new();

    // Core fields (always present)
    map.insert("originalROWID".to_string(), json!(chat.rowid));
    map.insert("guid".to_string(), json!(chat.guid));
    map.insert("style".to_string(), json!(chat.style));
    map.insert("chatIdentifier".to_string(), json!(chat.chat_identifier));
    map.insert("isArchived".to_string(), json!(chat.is_archived));
    map.insert("displayName".to_string(), json!(chat.display_name));

    // Participants
    if config.include_participants {
        map.insert(
            "participants".to_string(),
            serialize_handles(&chat.participants, is_for_notification),
        );
    }

    // Messages (always empty array in list context, populated on demand)
    if config.include_messages {
        map.insert("messages".to_string(), json!([]));
    }

    // Non-notification fields
    if !is_for_notification {
        map.insert("isFiltered".to_string(), json!(chat.is_filtered));
        map.insert("groupId".to_string(), json!(chat.group_id));
        // Decode the properties blob (binary plist) to JSON
        let properties = chat
            .properties
            .as_deref()
            .and_then(plist_decode::decode_chat_properties)
            .unwrap_or(Value::Null);
        map.insert("properties".to_string(), properties);
        map.insert(
            "lastAddressedHandle".to_string(),
            json!(chat.last_addressed_handle),
        );
    }

    Value::Object(map)
}

/// Serialize a list of Chats to JSON.
pub fn serialize_chats(
    chats: &[Chat],
    config: &ChatSerializerConfig,
    is_for_notification: bool,
) -> Value {
    let list: Vec<Value> = chats
        .iter()
        .map(|c| serialize_chat(c, config, is_for_notification))
        .collect();
    Value::Array(list)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn test_chat() -> Chat {
        Chat {
            rowid: 1,
            guid: "iMessage;-;+15551234567".to_string(),
            style: 45,
            chat_identifier: Some("+15551234567".to_string()),
            is_archived: false,
            display_name: None,
            is_filtered: false,
            group_id: None,
            last_addressed_handle: None,
            ..Default::default()
        }
    }

    #[test]
    fn serialize_full_chat() {
        let config = ChatSerializerConfig::default();
        let json = serialize_chat(&test_chat(), &config, false);
        assert_eq!(json["originalROWID"], 1);
        assert_eq!(json["guid"], "iMessage;-;+15551234567");
        assert_eq!(json["style"], 45);
        assert_eq!(json["isArchived"], false);
        assert!(json.get("isFiltered").is_some());
        assert!(json.get("groupId").is_some());
        assert!(json.get("properties").is_some());
        assert!(json.get("lastAddressedHandle").is_some());
    }

    #[test]
    fn serialize_notification_chat() {
        let config = ChatSerializerConfig::default();
        let json = serialize_chat(&test_chat(), &config, true);
        assert_eq!(json["originalROWID"], 1);
        assert!(json.get("isFiltered").is_none());
        assert!(json.get("groupId").is_none());
    }

    #[test]
    fn participants_included_by_default() {
        let config = ChatSerializerConfig::default();
        let json = serialize_chat(&test_chat(), &config, false);
        assert!(json.get("participants").is_some());
        assert!(json["participants"].is_array());
    }

    #[test]
    fn participants_excluded_when_configured() {
        let config = ChatSerializerConfig {
            include_participants: false,
            ..Default::default()
        };
        let json = serialize_chat(&test_chat(), &config, false);
        assert!(json.get("participants").is_none());
    }
}