Skip to main content

coven_database/
members.rs

1//! Members, devices and circles as the committed prefix has them (E9, E12).
2//! Each call and its live subscription run the same query.
3
4use crate::sqlite::StoreSql;
5use crate::{store_state::DeviceState, DbError};
6use coven_format::admin::{MemberPublicKeys, MemberRole};
7use coven_foundation::id_source::{CircleId, DeviceId, MemberId};
8
9/// A live member and every device they registered (E9).
10#[derive(Clone, Debug, PartialEq, Eq)]
11pub struct MemberInfo {
12    /// The stable member id, independent of its keys (§10).
13    pub id: MemberId,
14    /// The current public signing and sealing pair.
15    pub keys: MemberPublicKeys,
16    /// Current store role.
17    pub role: MemberRole,
18    /// How the member reaches storage: their provider account, or the id of
19    /// the S3 key they use, never its secret (§14.3). `None` for the store's
20    /// creator before Set up storage records theirs (§10.3).
21    pub access: Option<coven_format::MemberAccess>,
22    /// Every registered device, including removed and replaced ids.
23    pub devices: Vec<DeviceInfo>,
24    /// Whether this is the local member.
25    pub is_self: bool,
26}
27
28/// One of a member's device ids in the committed prefix (E9).
29#[derive(Clone, Debug, PartialEq, Eq)]
30pub struct DeviceInfo {
31    /// The device id.
32    pub id: DeviceId,
33    /// Its name from its registration.
34    pub name: String,
35    /// Active, removed, or replaced by a kept registration (§14.1).
36    pub state: DeviceState,
37    /// Whether this is the local installation, regardless of registration state.
38    pub is_self: bool,
39}
40
41/// A circle the local member belongs to (E12).
42#[derive(Clone, Debug, PartialEq, Eq)]
43pub struct Circle {
44    /// Circle identity.
45    pub id: CircleId,
46    /// Current name.
47    pub name: String,
48}
49
50/// An active store member in a circle (E12).
51#[derive(Clone, Debug, PartialEq, Eq)]
52pub struct CircleMemberInfo {
53    /// The stable member id, independent of its keys (§10).
54    pub member: MemberId,
55    /// Whether this is the local member.
56    pub is_self: bool,
57}
58
59use crate::store_state_tables::{circle, device_member, member};
60
61pub(crate) fn members(db: &StoreSql, device: DeviceId) -> Result<Vec<MemberInfo>, DbError> {
62    let me = device_member(db, device)?;
63    let members = db.query(
64        "SELECT member,signing,sealing,role,removed,access,joined_circle,joined_person FROM _coven_members WHERE removed=0
65         ORDER BY member",
66        [],
67        crate::store_state_tables::stored_member,
68    )?;
69    members
70        .into_iter()
71        .map(|(id, crate::StoreMember { keys, access, role, .. })| {
72            let devices = db.query(
73                "SELECT device,name,state FROM _coven_devices WHERE member=?1 ORDER BY device",
74                [id],
75                |r| {
76                    let id = r.get::<_, DeviceId>(0)?;
77                    Ok(DeviceInfo {
78                        id,
79                        is_self: id == device,
80                        name: r.get(1)?,
81                        state: crate::write_encoding::stored(
82                            r,
83                            2,
84                            sqlive::rusqlite::types::Type::Text,
85                        )?,
86                    })
87                },
88            )?;
89            Ok(MemberInfo { is_self: me.as_ref() == Some(&id), keys, id, role, access, devices })
90        })
91        .collect()
92}
93
94pub(crate) fn circles(db: &StoreSql, device: DeviceId) -> Result<Vec<Circle>, DbError> {
95    let Some(me) = device_member(db, device)? else {
96        return Ok(Vec::new());
97    };
98    // Ordered by the membership's circle, which the member's index holds in
99    // order; `c.circle` is the same value but would be sorted after the join.
100    let circles = db.query(
101        "SELECT c.circle,c.name FROM _coven_circle_members m JOIN _coven_circles c ON c.circle=m.circle
102         WHERE m.member=?1 AND NOT EXISTS(SELECT 1 FROM _coven_circle_deletions d WHERE d.circle=c.circle)
103         ORDER BY m.circle",
104        [me],
105        |r| {
106            Ok(Circle {
107                id: circle(r, 0)?,
108                name: r.get(1)?,
109            })
110        },
111    )?;
112    Ok(circles)
113}
114
115/// A circle's members who remain in the store; none for an absent or deleted circle.
116pub(crate) fn circle_members(
117    db: &StoreSql,
118    device: DeviceId,
119    circle: CircleId,
120) -> Result<Vec<CircleMemberInfo>, DbError> {
121    let me = device_member(db, device)?;
122    let members = db.query(
123        "SELECT m.member FROM _coven_circle_members m JOIN _coven_members s ON s.member=m.member
124         WHERE m.circle=?1 AND s.removed=0
125           AND NOT EXISTS(SELECT 1 FROM _coven_circle_deletions d WHERE d.circle=m.circle)
126         ORDER BY m.member",
127        [circle],
128        |r| member(r, 0),
129    )?;
130    Ok(members
131        .into_iter()
132        .map(|member| CircleMemberInfo { is_self: me.as_ref() == Some(&member), member })
133        .collect())
134}
135
136#[cfg(test)]
137#[path = "members_tests.rs"]
138mod tests;