io-email 0.1.0

Email client library
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

//! JMAP mailbox-create coroutine wrapping Mailbox/set { create }
//! (RFC 8621 ยง2.6).
//!
//! Creates a top-level mailbox; parent/role/sort-order belong to a
//! protocol-specific extension.
//!
//! # Example
//!
//! ```rust,ignore
//! use io_email::mailbox::jmap::create::JmapMailboxCreate;
//!
//! client.run(JmapMailboxCreate::new(&session, &auth, "Archive")?)?;
//! ```

use alloc::{collections::BTreeMap, string::String};

use io_jmap::{
    coroutine::{JmapCoroutine, JmapCoroutineState, JmapYield},
    rfc8620::JmapSession,
    rfc8621::mailbox::{
        JmapMailboxCreate as Patch,
        set::{JmapMailboxSet as InnerSet, JmapMailboxSetArgs, JmapMailboxSetError as InnerErr},
    },
};
use log::trace;
use secrecy::SecretString;
use thiserror::Error;

/// Errors produced by [`JmapMailboxCreate`].
#[derive(Debug, Error)]
pub enum JmapMailboxCreateError {
    #[error(transparent)]
    Set(#[from] InnerErr),
    #[error("Mailbox/set did not create a mailbox for `{0}`")]
    NotCreated(String),
}

/// I/O-free coroutine creating a JMAP mailbox named `name`.
pub struct JmapMailboxCreate {
    inner: InnerSet,
    client_id: String,
}

impl JmapMailboxCreate {
    pub fn new(
        session: &JmapSession,
        http_auth: &SecretString,
        name: &str,
    ) -> Result<Self, JmapMailboxCreateError> {
        trace!("prepare JMAP mailbox create");
        let client_id = String::from("new");
        let mut create = BTreeMap::new();
        create.insert(
            client_id.clone(),
            Patch {
                name: Some(name.into()),
                ..Patch::default()
            },
        );
        let args = JmapMailboxSetArgs {
            create: Some(create),
            ..JmapMailboxSetArgs::default()
        };
        let inner = InnerSet::new(session, http_auth, args)?;
        Ok(Self { inner, client_id })
    }
}

impl JmapCoroutine for JmapMailboxCreate {
    type Yield = JmapYield;
    type Return = Result<(), JmapMailboxCreateError>;

    fn resume(&mut self, bytes: Option<&[u8]>) -> JmapCoroutineState<Self::Yield, Self::Return> {
        match self.inner.resume(bytes) {
            JmapCoroutineState::Yielded(y) => JmapCoroutineState::Yielded(y),
            JmapCoroutineState::Complete(Ok(ok)) => {
                if ok.created.contains_key(&self.client_id) {
                    JmapCoroutineState::Complete(Ok(()))
                } else {
                    JmapCoroutineState::Complete(Err(JmapMailboxCreateError::NotCreated(
                        self.client_id.clone(),
                    )))
                }
            }
            JmapCoroutineState::Complete(Err(err)) => JmapCoroutineState::Complete(Err(err.into())),
        }
    }
}