agent-team-mail-core 1.1.2

Daemon-free core library for local agent team mail workflows.
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
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161

use std::marker::PhantomData;

use crate::schema::MessageEnvelope;
use crate::types::{
    AckState, AcknowledgedAckState, DisplayBucket, IsoTimestamp, MessageClass, NoAckState,
    PendingAckState, ReadReadState, ReadState, UnreadReadState,
};

#[derive(Debug, Clone)]
pub struct StoredMessage<R, A> {
    pub envelope: MessageEnvelope,
    _read: PhantomData<R>, // covariant in R; the typestate marker is never mutably borrowed.
    _ack: PhantomData<A>,  // covariant in A; the typestate marker is never mutably borrowed.
}

impl StoredMessage<UnreadReadState, NoAckState> {
    pub(crate) fn unread_no_ack(envelope: MessageEnvelope) -> Self {
        Self {
            envelope,
            _read: PhantomData,
            _ack: PhantomData,
        }
    }

    pub fn display_without_ack(self) -> StoredMessage<ReadReadState, NoAckState> {
        self.mark_read()
    }

    pub fn display_and_require_ack(
        mut self,
        at: IsoTimestamp,
    ) -> StoredMessage<ReadReadState, PendingAckState> {
        self.envelope.read = true;
        self.envelope.pending_ack_at = Some(at);
        StoredMessage::read_pending_ack(self.envelope)
    }

    pub fn mark_read(mut self) -> StoredMessage<ReadReadState, NoAckState> {
        self.envelope.read = true;
        StoredMessage::read_no_ack(self.envelope)
    }
}

impl StoredMessage<UnreadReadState, PendingAckState> {
    pub(crate) fn unread_pending_ack(envelope: MessageEnvelope) -> Self {
        Self {
            envelope,
            _read: PhantomData,
            _ack: PhantomData,
        }
    }

    pub fn mark_read_pending_ack(mut self) -> StoredMessage<ReadReadState, PendingAckState> {
        self.envelope.read = true;
        StoredMessage::read_pending_ack(self.envelope)
    }
}

impl StoredMessage<ReadReadState, NoAckState> {
    pub(crate) fn read_no_ack(envelope: MessageEnvelope) -> Self {
        Self {
            envelope,
            _read: PhantomData,
            _ack: PhantomData,
        }
    }
}

impl StoredMessage<ReadReadState, PendingAckState> {
    pub(crate) fn read_pending_ack(envelope: MessageEnvelope) -> Self {
        Self {
            envelope,
            _read: PhantomData,
            _ack: PhantomData,
        }
    }

    pub fn acknowledge(
        mut self,
        at: IsoTimestamp,
    ) -> StoredMessage<ReadReadState, AcknowledgedAckState> {
        self.envelope.acknowledged_at = Some(at);
        self.envelope.pending_ack_at = None;
        StoredMessage::read_acknowledged(self.envelope)
    }
}

impl StoredMessage<ReadReadState, AcknowledgedAckState> {
    pub(crate) fn read_acknowledged(envelope: MessageEnvelope) -> Self {
        Self {
            envelope,
            _read: PhantomData,
            _ack: PhantomData,
        }
    }
}

#[derive(Debug, Clone)]
pub enum TransitionedMessage {
    ReadNoAck(StoredMessage<ReadReadState, NoAckState>),
    ReadPendingAck(StoredMessage<ReadReadState, PendingAckState>),
    Unchanged(MessageEnvelope),
}

impl TransitionedMessage {
    pub fn into_envelope(self) -> MessageEnvelope {
        match self {
            Self::ReadNoAck(message) => message.envelope,
            Self::ReadPendingAck(message) => message.envelope,
            Self::Unchanged(envelope) => envelope,
        }
    }
}

pub fn derive_read_state(message: &MessageEnvelope) -> ReadState {
    if message.read {
        ReadState::Read
    } else {
        ReadState::Unread
    }
}

pub fn derive_ack_state(message: &MessageEnvelope) -> AckState {
    if message.acknowledged_at.is_some() {
        AckState::Acknowledged
    } else if message.pending_ack_at.is_some() {
        AckState::PendingAck
    } else {
        AckState::NoAckRequired
    }
}

pub fn classify_message(message: &MessageEnvelope) -> MessageClass {
    let read_state = derive_read_state(message);
    let ack_state = derive_ack_state(message);

    debug_assert!(
        !matches!(
            (read_state, ack_state),
            (ReadState::Unread, AckState::Acknowledged)
        ),
        "inconsistent message state: unread message cannot already be acknowledged"
    );

    match (read_state, ack_state) {
        (ReadState::Unread, AckState::NoAckRequired) => MessageClass::Unread,
        (ReadState::Unread, AckState::PendingAck) => MessageClass::PendingAck,
        (ReadState::Unread, AckState::Acknowledged) => MessageClass::Acknowledged,
        (ReadState::Read, AckState::NoAckRequired) => MessageClass::Read,
        (ReadState::Read, AckState::PendingAck) => MessageClass::PendingAck,
        (ReadState::Read, AckState::Acknowledged) => MessageClass::Acknowledged,
    }
}

pub fn display_bucket_for_class(class: MessageClass) -> DisplayBucket {
    match class {
        MessageClass::Unread => DisplayBucket::Unread,
        MessageClass::PendingAck => DisplayBucket::PendingAck,
        MessageClass::Acknowledged | MessageClass::Read => DisplayBucket::History,
    }
}