im-core 0.1.0

Rust IM SDK for Awiki clients built on Agent Network Protocol (ANP)
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

#[cfg(feature = "sqlite")]
pub(crate) mod actor;

pub(crate) mod attachment_manifest_cache;
pub(crate) mod contacts;
#[cfg(feature = "sqlite")]
pub(crate) mod conversation_summaries;
pub(crate) mod conversations;
pub(crate) mod email;
pub(crate) mod groups;
pub(crate) mod messages;
pub(crate) mod owner_scope;
pub(crate) mod read_state;
pub(crate) mod sync_state;

#[cfg(feature = "sqlite")]
pub(crate) mod schema;

#[cfg(feature = "sqlite")]
#[allow(dead_code)]
pub(crate) trait LocalStateStore {
    fn ensure_schema(&self) -> crate::ImResult<()>;

    fn current_schema_version(&self) -> crate::ImResult<i64>;

    fn store_message(&mut self, _record: messages::MessageRecord) -> crate::ImResult<()> {
        Err(unsupported_operation("store_message"))
    }

    fn store_messages(&mut self, _records: &[messages::MessageRecord]) -> crate::ImResult<()> {
        Err(unsupported_operation("store_messages"))
    }

    fn upsert_contact(&mut self, _record: contacts::ContactRecord) -> crate::ImResult<()> {
        Err(unsupported_operation("upsert_contact"))
    }

    fn upsert_group(&mut self, _record: groups::GroupRecord) -> crate::ImResult<()> {
        Err(unsupported_operation("upsert_group"))
    }

    fn upsert_group_member(&mut self, _record: groups::GroupMemberRecord) -> crate::ImResult<()> {
        Err(unsupported_operation("upsert_group_member"))
    }

    fn list_conversations(
        &self,
        _owner_did: &str,
        _limit: i64,
    ) -> crate::ImResult<Vec<conversations::ConversationRecord>> {
        Err(unsupported_operation("list_conversations"))
    }
}

#[cfg(feature = "sqlite")]
impl LocalStateStore for rusqlite::Connection {
    fn ensure_schema(&self) -> crate::ImResult<()> {
        schema::ensure_schema(self)
    }

    fn current_schema_version(&self) -> crate::ImResult<i64> {
        schema::current_schema_version(self)
    }

    fn store_message(&mut self, record: messages::MessageRecord) -> crate::ImResult<()> {
        messages::upsert_message(self, &record)
    }

    fn store_messages(&mut self, records: &[messages::MessageRecord]) -> crate::ImResult<()> {
        messages::upsert_messages(self, records)
    }
}

#[cfg(feature = "sqlite")]
pub(crate) fn open_writable(path: &std::path::Path) -> crate::ImResult<rusqlite::Connection> {
    if let Some(parent) = path.parent() {
        std::fs::create_dir_all(parent)?;
    }
    let connection = rusqlite::Connection::open(path).map_err(local_state_unavailable)?;
    configure(&connection)?;
    schema::ensure_schema(&connection)?;
    Ok(connection)
}

#[cfg(feature = "sqlite")]
pub(crate) fn configure(connection: &rusqlite::Connection) -> crate::ImResult<()> {
    connection
        .pragma_update(None, "journal_mode", "WAL")
        .map_err(local_state_unavailable)?;
    connection
        .pragma_update(None, "foreign_keys", "ON")
        .map_err(local_state_unavailable)?;
    connection
        .pragma_update(None, "busy_timeout", 5000)
        .map_err(local_state_unavailable)?;
    connection
        .pragma_update(None, "mmap_size", 0)
        .map_err(local_state_unavailable)?;
    Ok(())
}

#[cfg(feature = "sqlite")]
pub(crate) fn local_state_unavailable(err: impl std::fmt::Display) -> crate::ImError {
    crate::ImError::LocalStateUnavailable {
        detail: err.to_string(),
    }
}

#[cfg(feature = "sqlite")]
#[allow(dead_code)]
fn unsupported_operation(name: &str) -> crate::ImError {
    crate::ImError::unsupported(format!("local_state.{name}"))
}