WIP refactor

5 files changed, 0 insertions, 1264 deletions

diff --git a/src/imap/command/anonymous.rs b/src/imap/command/anonymous.rs
deleted file mode 100644
index 811d1e4..0000000
--- a/src/imap/command/anonymous.rs
+++ /dev/null
@@ -1,83 +0,0 @@
-use anyhow::Result;
-use imap_codec::imap_types::command::{Command, CommandBody};
-use imap_codec::imap_types::core::AString;
-use imap_codec::imap_types::response::Code;
-use imap_codec::imap_types::secret::Secret;
-
-use crate::imap::capability::ServerCapability;
-use crate::imap::command::anystate;
-use crate::imap::flow;
-use crate::imap::response::Response;
-use crate::login::ArcLoginProvider;
-use crate::user::User;
-
-//--- dispatching
-
-pub struct AnonymousContext<'a> {
-    pub req: &'a Command<'static>,
-    pub server_capabilities: &'a ServerCapability,
-    pub login_provider: &'a ArcLoginProvider,
-}
-
-pub async fn dispatch(ctx: AnonymousContext<'_>) -> Result<(Response<'static>, flow::Transition)> {
-    match &ctx.req.body {
-        // Any State
-        CommandBody::Noop => anystate::noop_nothing(ctx.req.tag.clone()),
-        CommandBody::Capability => {
-            anystate::capability(ctx.req.tag.clone(), ctx.server_capabilities)
-        }
-        CommandBody::Logout => anystate::logout(),
-
-        // Specific to anonymous context (3 commands)
-        CommandBody::Login { username, password } => ctx.login(username, password).await,
-        CommandBody::Authenticate { .. } => {
-            anystate::not_implemented(ctx.req.tag.clone(), "authenticate")
-        }
-        //StartTLS is not implemented for now, we will probably go full TLS.
-
-        // Collect other commands
-        _ => anystate::wrong_state(ctx.req.tag.clone()),
-    }
-}
-
-//--- Command controllers, private
-
-impl<'a> AnonymousContext<'a> {
-    async fn login(
-        self,
-        username: &AString<'a>,
-        password: &Secret<AString<'a>>,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let (u, p) = (
-            std::str::from_utf8(username.as_ref())?,
-            std::str::from_utf8(password.declassify().as_ref())?,
-        );
-        tracing::info!(user = %u, "command.login");
-
-        let creds = match self.login_provider.login(&u, &p).await {
-            Err(e) => {
-                tracing::debug!(error=%e, "authentication failed");
-                return Ok((
-                    Response::build()
-                        .to_req(self.req)
-                        .message("Authentication failed")
-                        .no()?,
-                    flow::Transition::None,
-                ));
-            }
-            Ok(c) => c,
-        };
-
-        let user = User::new(u.to_string(), creds).await?;
-
-        tracing::info!(username=%u, "connected");
-        Ok((
-            Response::build()
-                .to_req(self.req)
-                .code(Code::Capability(self.server_capabilities.to_vec()))
-                .message("Completed")
-                .ok()?,
-            flow::Transition::Authenticate(user),
-        ))
-    }
-}
diff --git a/src/imap/command/anystate.rs b/src/imap/command/anystate.rs
deleted file mode 100644
index 718ba3f..0000000
--- a/src/imap/command/anystate.rs
+++ /dev/null
@@ -1,54 +0,0 @@
-use anyhow::Result;
-use imap_codec::imap_types::core::Tag;
-use imap_codec::imap_types::response::Data;
-
-use crate::imap::capability::ServerCapability;
-use crate::imap::flow;
-use crate::imap::response::Response;
-
-pub(crate) fn capability(
-    tag: Tag<'static>,
-    cap: &ServerCapability,
-) -> Result<(Response<'static>, flow::Transition)> {
-    let res = Response::build()
-        .tag(tag)
-        .message("Server capabilities")
-        .data(Data::Capability(cap.to_vec()))
-        .ok()?;
-
-    Ok((res, flow::Transition::None))
-}
-
-pub(crate) fn noop_nothing(tag: Tag<'static>) -> Result<(Response<'static>, flow::Transition)> {
-    Ok((
-        Response::build().tag(tag).message("Noop completed.").ok()?,
-        flow::Transition::None,
-    ))
-}
-
-pub(crate) fn logout() -> Result<(Response<'static>, flow::Transition)> {
-    Ok((Response::bye()?, flow::Transition::Logout))
-}
-
-pub(crate) fn not_implemented<'a>(
-    tag: Tag<'a>,
-    what: &str,
-) -> Result<(Response<'a>, flow::Transition)> {
-    Ok((
-        Response::build()
-            .tag(tag)
-            .message(format!("Command not implemented {}", what))
-            .bad()?,
-        flow::Transition::None,
-    ))
-}
-
-pub(crate) fn wrong_state(tag: Tag<'static>) -> Result<(Response<'static>, flow::Transition)> {
-    Ok((
-        Response::build()
-            .tag(tag)
-            .message("Command not authorized in this state")
-            .bad()?,
-        flow::Transition::None,
-    ))
-}
diff --git a/src/imap/command/authenticated.rs b/src/imap/command/authenticated.rs
deleted file mode 100644
index 3d332ec..0000000
--- a/src/imap/command/authenticated.rs
+++ /dev/null
@@ -1,683 +0,0 @@
-use std::collections::BTreeMap;
-use std::sync::Arc;
-use thiserror::Error;
-
-use anyhow::{anyhow, bail, Result};
-use imap_codec::imap_types::command::{
-    Command, CommandBody, ListReturnItem, SelectExamineModifier,
-};
-use imap_codec::imap_types::core::{Atom, Literal, QuotedChar, Vec1};
-use imap_codec::imap_types::datetime::DateTime;
-use imap_codec::imap_types::extensions::enable::CapabilityEnable;
-use imap_codec::imap_types::flag::{Flag, FlagNameAttribute};
-use imap_codec::imap_types::mailbox::{ListMailbox, Mailbox as MailboxCodec};
-use imap_codec::imap_types::response::{Code, CodeOther, Data};
-use imap_codec::imap_types::status::{StatusDataItem, StatusDataItemName};
-
-use crate::imap::capability::{ClientCapability, ServerCapability};
-use crate::imap::command::{anystate, MailboxName};
-use crate::imap::flow;
-use crate::imap::mailbox_view::{MailboxView, UpdateParameters};
-use crate::imap::response::Response;
-use crate::imap::Body;
-
-use crate::mail::uidindex::*;
-use crate::user::User;
-use crate::mail::IMF;
-use crate::mail::namespace::MAILBOX_HIERARCHY_DELIMITER as MBX_HIER_DELIM_RAW;
-
-pub struct AuthenticatedContext<'a> {
-    pub req: &'a Command<'static>,
-    pub server_capabilities: &'a ServerCapability,
-    pub client_capabilities: &'a mut ClientCapability,
-    pub user: &'a Arc<User>,
-}
-
-pub async fn dispatch<'a>(
-    mut ctx: AuthenticatedContext<'a>,
-) -> Result<(Response<'static>, flow::Transition)> {
-    match &ctx.req.body {
-        // Any state
-        CommandBody::Noop => anystate::noop_nothing(ctx.req.tag.clone()),
-        CommandBody::Capability => {
-            anystate::capability(ctx.req.tag.clone(), ctx.server_capabilities)
-        }
-        CommandBody::Logout => anystate::logout(),
-
-        // Specific to this state (11 commands)
-        CommandBody::Create { mailbox } => ctx.create(mailbox).await,
-        CommandBody::Delete { mailbox } => ctx.delete(mailbox).await,
-        CommandBody::Rename { from, to } => ctx.rename(from, to).await,
-        CommandBody::Lsub {
-            reference,
-            mailbox_wildcard,
-        } => ctx.list(reference, mailbox_wildcard, &[], true).await,
-        CommandBody::List {
-            reference,
-            mailbox_wildcard,
-            r#return,
-        } => ctx.list(reference, mailbox_wildcard, r#return, false).await,
-        CommandBody::Status {
-            mailbox,
-            item_names,
-        } => ctx.status(mailbox, item_names).await,
-        CommandBody::Subscribe { mailbox } => ctx.subscribe(mailbox).await,
-        CommandBody::Unsubscribe { mailbox } => ctx.unsubscribe(mailbox).await,
-        CommandBody::Select { mailbox, modifiers } => ctx.select(mailbox, modifiers).await,
-        CommandBody::Examine { mailbox, modifiers } => ctx.examine(mailbox, modifiers).await,
-        CommandBody::Append {
-            mailbox,
-            flags,
-            date,
-            message,
-        } => ctx.append(mailbox, flags, date, message).await,
-
-        // rfc5161 ENABLE
-        CommandBody::Enable { capabilities } => ctx.enable(capabilities),
-
-        // Collect other commands
-        _ => anystate::wrong_state(ctx.req.tag.clone()),
-    }
-}
-
-// --- PRIVATE ---
-impl<'a> AuthenticatedContext<'a> {
-    async fn create(
-        self,
-        mailbox: &MailboxCodec<'a>,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let name = match mailbox {
-            MailboxCodec::Inbox => {
-                return Ok((
-                    Response::build()
-                        .to_req(self.req)
-                        .message("Cannot create INBOX")
-                        .bad()?,
-                    flow::Transition::None,
-                ));
-            }
-            MailboxCodec::Other(aname) => std::str::from_utf8(aname.as_ref())?,
-        };
-
-        match self.user.create_mailbox(&name).await {
-            Ok(()) => Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message("CREATE complete")
-                    .ok()?,
-                flow::Transition::None,
-            )),
-            Err(e) => Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message(&e.to_string())
-                    .no()?,
-                flow::Transition::None,
-            )),
-        }
-    }
-
-    async fn delete(
-        self,
-        mailbox: &MailboxCodec<'a>,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let name: &str = MailboxName(mailbox).try_into()?;
-
-        match self.user.delete_mailbox(&name).await {
-            Ok(()) => Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message("DELETE complete")
-                    .ok()?,
-                flow::Transition::None,
-            )),
-            Err(e) => Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message(e.to_string())
-                    .no()?,
-                flow::Transition::None,
-            )),
-        }
-    }
-
-    async fn rename(
-        self,
-        from: &MailboxCodec<'a>,
-        to: &MailboxCodec<'a>,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let name: &str = MailboxName(from).try_into()?;
-        let new_name: &str = MailboxName(to).try_into()?;
-
-        match self.user.rename_mailbox(&name, &new_name).await {
-            Ok(()) => Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message("RENAME complete")
-                    .ok()?,
-                flow::Transition::None,
-            )),
-            Err(e) => Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message(e.to_string())
-                    .no()?,
-                flow::Transition::None,
-            )),
-        }
-    }
-
-    async fn list(
-        &mut self,
-        reference: &MailboxCodec<'a>,
-        mailbox_wildcard: &ListMailbox<'a>,
-        must_return: &[ListReturnItem],
-        is_lsub: bool,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let mbx_hier_delim: QuotedChar = QuotedChar::unvalidated(MBX_HIER_DELIM_RAW);
-
-        let reference: &str = MailboxName(reference).try_into()?;
-        if !reference.is_empty() {
-            return Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message("References not supported")
-                    .bad()?,
-                flow::Transition::None,
-            ));
-        }
-
-        let status_item_names = must_return.iter().find_map(|m| match m {
-            ListReturnItem::Status(v) => Some(v),
-            _ => None,
-        });
-
-        // @FIXME would probably need a rewrite to better use the imap_codec library
-        let wildcard = match mailbox_wildcard {
-            ListMailbox::Token(v) => std::str::from_utf8(v.as_ref())?,
-            ListMailbox::String(v) => std::str::from_utf8(v.as_ref())?,
-        };
-        if wildcard.is_empty() {
-            if is_lsub {
-                return Ok((
-                    Response::build()
-                        .to_req(self.req)
-                        .message("LSUB complete")
-                        .data(Data::Lsub {
-                            items: vec![],
-                            delimiter: Some(mbx_hier_delim),
-                            mailbox: "".try_into().unwrap(),
-                        })
-                        .ok()?,
-                    flow::Transition::None,
-                ));
-            } else {
-                return Ok((
-                    Response::build()
-                        .to_req(self.req)
-                        .message("LIST complete")
-                        .data(Data::List {
-                            items: vec![],
-                            delimiter: Some(mbx_hier_delim),
-                            mailbox: "".try_into().unwrap(),
-                        })
-                        .ok()?,
-                    flow::Transition::None,
-                ));
-            }
-        }
-
-        let mailboxes = self.user.list_mailboxes().await?;
-        let mut vmailboxes = BTreeMap::new();
-        for mb in mailboxes.iter() {
-            for (i, _) in mb.match_indices(MBX_HIER_DELIM_RAW) {
-                if i > 0 {
-                    let smb = &mb[..i];
-                    vmailboxes.entry(smb).or_insert(false);
-                }
-            }
-            vmailboxes.insert(mb, true);
-        }
-
-        let mut ret = vec![];
-        for (mb, is_real) in vmailboxes.iter() {
-            if matches_wildcard(&wildcard, mb) {
-                let mailbox: MailboxCodec = mb
-                    .to_string()
-                    .try_into()
-                    .map_err(|_| anyhow!("invalid mailbox name"))?;
-                let mut items = vec![FlagNameAttribute::from(Atom::unvalidated("Subscribed"))];
-
-                // Decoration
-                if !*is_real {
-                    items.push(FlagNameAttribute::Noselect);
-                } else {
-                    match *mb {
-                        "Drafts" => items.push(Atom::unvalidated("Drafts").into()),
-                        "Archive" => items.push(Atom::unvalidated("Archive").into()),
-                        "Sent" => items.push(Atom::unvalidated("Sent").into()),
-                        "Trash" => items.push(Atom::unvalidated("Trash").into()),
-                        _ => (),
-                    };
-                }
-
-                // Result type
-                if is_lsub {
-                    ret.push(Data::Lsub {
-                        items,
-                        delimiter: Some(mbx_hier_delim),
-                        mailbox: mailbox.clone(),
-                    });
-                } else {
-                    ret.push(Data::List {
-                        items,
-                        delimiter: Some(mbx_hier_delim),
-                        mailbox: mailbox.clone(),
-                    });
-                }
-
-                // Also collect status
-                if let Some(sin) = status_item_names {
-                    let ret_attrs = match self.status_items(mb, sin).await {
-                        Ok(a) => a,
-                        Err(e) => {
-                            tracing::error!(err=?e, mailbox=%mb, "Unable to fetch status for mailbox");
-                            continue;
-                        }
-                    };
-
-                    let data = Data::Status {
-                        mailbox,
-                        items: ret_attrs.into(),
-                    };
-
-                    ret.push(data);
-                }
-            }
-        }
-
-        let msg = if is_lsub {
-            "LSUB completed"
-        } else {
-            "LIST completed"
-        };
-        Ok((
-            Response::build()
-                .to_req(self.req)
-                .message(msg)
-                .many_data(ret)
-                .ok()?,
-            flow::Transition::None,
-        ))
-    }
-
-    async fn status(
-        &mut self,
-        mailbox: &MailboxCodec<'static>,
-        attributes: &[StatusDataItemName],
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let name: &str = MailboxName(mailbox).try_into()?;
-
-        let ret_attrs = match self.status_items(name, attributes).await {
-            Ok(v) => v,
-            Err(e) => match e.downcast_ref::<CommandError>() {
-                Some(CommandError::MailboxNotFound) => {
-                    return Ok((
-                        Response::build()
-                            .to_req(self.req)
-                            .message("Mailbox does not exist")
-                            .no()?,
-                        flow::Transition::None,
-                    ))
-                }
-                _ => return Err(e.into()),
-            },
-        };
-
-        let data = Data::Status {
-            mailbox: mailbox.clone(),
-            items: ret_attrs.into(),
-        };
-
-        Ok((
-            Response::build()
-                .to_req(self.req)
-                .message("STATUS completed")
-                .data(data)
-                .ok()?,
-            flow::Transition::None,
-        ))
-    }
-
-    async fn status_items(
-        &mut self,
-        name: &str,
-        attributes: &[StatusDataItemName],
-    ) -> Result<Vec<StatusDataItem>> {
-        let mb_opt = self.user.open_mailbox(name).await?;
-        let mb = match mb_opt {
-            Some(mb) => mb,
-            None => return Err(CommandError::MailboxNotFound.into()),
-        };
-
-        let view = MailboxView::new(mb, self.client_capabilities.condstore.is_enabled()).await;
-
-        let mut ret_attrs = vec![];
-        for attr in attributes.iter() {
-            ret_attrs.push(match attr {
-                StatusDataItemName::Messages => StatusDataItem::Messages(view.exists()?),
-                StatusDataItemName::Unseen => StatusDataItem::Unseen(view.unseen_count() as u32),
-                StatusDataItemName::Recent => StatusDataItem::Recent(view.recent()?),
-                StatusDataItemName::UidNext => StatusDataItem::UidNext(view.uidnext()),
-                StatusDataItemName::UidValidity => {
-                    StatusDataItem::UidValidity(view.uidvalidity())
-                }
-                StatusDataItemName::Deleted => {
-                    bail!("quota not implemented, can't return deleted elements waiting for EXPUNGE");
-                },
-                StatusDataItemName::DeletedStorage => {
-                    bail!("quota not implemented, can't return freed storage after EXPUNGE will be run");
-                },
-                StatusDataItemName::HighestModSeq => {
-                    self.client_capabilities.enable_condstore();
-                    StatusDataItem::HighestModSeq(view.highestmodseq().get())
-                },
-            });
-        }
-        Ok(ret_attrs)
-    }
-
-    async fn subscribe(
-        self,
-        mailbox: &MailboxCodec<'a>,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let name: &str = MailboxName(mailbox).try_into()?;
-
-        if self.user.has_mailbox(&name).await? {
-            Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message("SUBSCRIBE complete")
-                    .ok()?,
-                flow::Transition::None,
-            ))
-        } else {
-            Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message(format!("Mailbox {} does not exist", name))
-                    .bad()?,
-                flow::Transition::None,
-            ))
-        }
-    }
-
-    async fn unsubscribe(
-        self,
-        mailbox: &MailboxCodec<'a>,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let name: &str = MailboxName(mailbox).try_into()?;
-
-        if self.user.has_mailbox(&name).await? {
-            Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message(format!(
-                        "Cannot unsubscribe from mailbox {}: not supported by Aerogramme",
-                        name
-                    ))
-                    .bad()?,
-                flow::Transition::None,
-            ))
-        } else {
-            Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message(format!("Mailbox {} does not exist", name))
-                    .no()?,
-                flow::Transition::None,
-            ))
-        }
-    }
-
-    /*
-    * TRACE BEGIN ---
-
-
-    Example:    C: A142 SELECT INBOX
-    S: * 172 EXISTS
-    S: * 1 RECENT
-    S: * OK [UNSEEN 12] Message 12 is first unseen
-    S: * OK [UIDVALIDITY 3857529045] UIDs valid
-    S: * OK [UIDNEXT 4392] Predicted next UID
-    S: * FLAGS (\Answered \Flagged \Deleted \Seen \Draft)
-    S: * OK [PERMANENTFLAGS (\Deleted \Seen \*)] Limited
-    S: A142 OK [READ-WRITE] SELECT completed
-
-    --- a mailbox with no unseen message -> no unseen entry
-    NOTES:
-      RFC3501 (imap4rev1) says if there is no OK [UNSEEN] response, client must make no assumption,
-                          it is therefore correct to not return it even if there are unseen messages
-      RFC9051 (imap4rev2) says that OK [UNSEEN] responses are deprecated after SELECT and EXAMINE
-      For Aerogramme, we just don't send the OK [UNSEEN], it's correct to do in both specifications.
-
-
-    20 select "INBOX.achats"
-    * FLAGS (\Answered \Flagged \Deleted \Seen \Draft $Forwarded JUNK $label1)
-    * OK [PERMANENTFLAGS (\Answered \Flagged \Deleted \Seen \Draft $Forwarded JUNK $label1 \*)] Flags permitted.
-    * 88 EXISTS
-    * 0 RECENT
-    * OK [UIDVALIDITY 1347986788] UIDs valid
-    * OK [UIDNEXT 91] Predicted next UID
-    * OK [HIGHESTMODSEQ 72] Highest
-    20 OK [READ-WRITE] Select completed (0.001 + 0.000 secs).
-
-    * TRACE END ---
-    */
-    async fn select(
-        self,
-        mailbox: &MailboxCodec<'a>,
-        modifiers: &[SelectExamineModifier],
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        self.client_capabilities.select_enable(modifiers);
-
-        let name: &str = MailboxName(mailbox).try_into()?;
-
-        let mb_opt = self.user.open_mailbox(&name).await?;
-        let mb = match mb_opt {
-            Some(mb) => mb,
-            None => {
-                return Ok((
-                    Response::build()
-                        .to_req(self.req)
-                        .message("Mailbox does not exist")
-                        .no()?,
-                    flow::Transition::None,
-                ))
-            }
-        };
-        tracing::info!(username=%self.user.username, mailbox=%name, "mailbox.selected");
-
-        let mb = MailboxView::new(mb, self.client_capabilities.condstore.is_enabled()).await;
-        let data = mb.summary()?;
-
-        Ok((
-            Response::build()
-                .message("Select completed")
-                .to_req(self.req)
-                .code(Code::ReadWrite)
-                .set_body(data)
-                .ok()?,
-            flow::Transition::Select(mb, flow::MailboxPerm::ReadWrite),
-        ))
-    }
-
-    async fn examine(
-        self,
-        mailbox: &MailboxCodec<'a>,
-        modifiers: &[SelectExamineModifier],
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        self.client_capabilities.select_enable(modifiers);
-
-        let name: &str = MailboxName(mailbox).try_into()?;
-
-        let mb_opt = self.user.open_mailbox(&name).await?;
-        let mb = match mb_opt {
-            Some(mb) => mb,
-            None => {
-                return Ok((
-                    Response::build()
-                        .to_req(self.req)
-                        .message("Mailbox does not exist")
-                        .no()?,
-                    flow::Transition::None,
-                ))
-            }
-        };
-        tracing::info!(username=%self.user.username, mailbox=%name, "mailbox.examined");
-
-        let mb = MailboxView::new(mb, self.client_capabilities.condstore.is_enabled()).await;
-        let data = mb.summary()?;
-
-        Ok((
-            Response::build()
-                .to_req(self.req)
-                .message("Examine completed")
-                .code(Code::ReadOnly)
-                .set_body(data)
-                .ok()?,
-            flow::Transition::Select(mb, flow::MailboxPerm::ReadOnly),
-        ))
-    }
-
-    //@FIXME we should write a specific version for the "selected" state
-    //that returns some unsollicited responses
-    async fn append(
-        self,
-        mailbox: &MailboxCodec<'a>,
-        flags: &[Flag<'a>],
-        date: &Option<DateTime>,
-        message: &Literal<'a>,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let append_tag = self.req.tag.clone();
-        match self.append_internal(mailbox, flags, date, message).await {
-            Ok((_mb_view, uidvalidity, uid, _modseq)) => Ok((
-                Response::build()
-                    .tag(append_tag)
-                    .message("APPEND completed")
-                    .code(Code::Other(CodeOther::unvalidated(
-                        format!("APPENDUID {} {}", uidvalidity, uid).into_bytes(),
-                    )))
-                    .ok()?,
-                flow::Transition::None,
-            )),
-            Err(e) => Ok((
-                Response::build()
-                    .tag(append_tag)
-                    .message(e.to_string())
-                    .no()?,
-                flow::Transition::None,
-            )),
-        }
-    }
-
-    fn enable(
-        self,
-        cap_enable: &Vec1<CapabilityEnable<'static>>,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let mut response_builder = Response::build().to_req(self.req);
-        let capabilities = self.client_capabilities.try_enable(cap_enable.as_ref());
-        if capabilities.len() > 0 {
-            response_builder = response_builder.data(Data::Enabled { capabilities });
-        }
-        Ok((
-            response_builder.message("ENABLE completed").ok()?,
-            flow::Transition::None,
-        ))
-    }
-
-    //@FIXME should be refactored and integrated to the mailbox view
-    pub(crate) async fn append_internal(
-        self,
-        mailbox: &MailboxCodec<'a>,
-        flags: &[Flag<'a>],
-        date: &Option<DateTime>,
-        message: &Literal<'a>,
-    ) -> Result<(MailboxView, ImapUidvalidity, ImapUid, ModSeq)> {
-        let name: &str = MailboxName(mailbox).try_into()?;
-
-        let mb_opt = self.user.open_mailbox(&name).await?;
-        let mb = match mb_opt {
-            Some(mb) => mb,
-            None => bail!("Mailbox does not exist"),
-        };
-        let mut view = MailboxView::new(mb, self.client_capabilities.condstore.is_enabled()).await;
-
-        if date.is_some() {
-            tracing::warn!("Cannot set date when appending message");
-        }
-
-        let msg =
-            IMF::try_from(message.data()).map_err(|_| anyhow!("Could not parse e-mail message"))?;
-        let flags = flags.iter().map(|x| x.to_string()).collect::<Vec<_>>();
-        // TODO: filter allowed flags? ping @Quentin
-
-        let (uidvalidity, uid, modseq) =
-            view.internal.mailbox.append(msg, None, &flags[..]).await?;
-        //let unsollicited = view.update(UpdateParameters::default()).await?;
-
-        Ok((view, uidvalidity, uid, modseq))
-    }
-}
-
-fn matches_wildcard(wildcard: &str, name: &str) -> bool {
-    let wildcard = wildcard.chars().collect::<Vec<char>>();
-    let name = name.chars().collect::<Vec<char>>();
-
-    let mut matches = vec![vec![false; wildcard.len() + 1]; name.len() + 1];
-
-    for i in 0..=name.len() {
-        for j in 0..=wildcard.len() {
-            matches[i][j] = (i == 0 && j == 0)
-                || (j > 0
-                    && matches[i][j - 1]
-                    && (wildcard[j - 1] == '%' || wildcard[j - 1] == '*'))
-                || (i > 0
-                    && j > 0
-                    && matches[i - 1][j - 1]
-                    && wildcard[j - 1] == name[i - 1]
-                    && wildcard[j - 1] != '%'
-                    && wildcard[j - 1] != '*')
-                || (i > 0
-                    && j > 0
-                    && matches[i - 1][j]
-                    && (wildcard[j - 1] == '*'
-                        || (wildcard[j - 1] == '%' && name[i - 1] != MBX_HIER_DELIM_RAW)));
-        }
-    }
-
-    matches[name.len()][wildcard.len()]
-}
-
-#[derive(Error, Debug)]
-pub enum CommandError {
-    #[error("Mailbox not found")]
-    MailboxNotFound,
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_wildcard_matches() {
-        assert!(matches_wildcard("INBOX", "INBOX"));
-        assert!(matches_wildcard("*", "INBOX"));
-        assert!(matches_wildcard("%", "INBOX"));
-        assert!(!matches_wildcard("%", "Test.Azerty"));
-        assert!(!matches_wildcard("INBOX.*", "INBOX"));
-        assert!(matches_wildcard("Sent.*", "Sent.A"));
-        assert!(matches_wildcard("Sent.*", "Sent.A.B"));
-        assert!(!matches_wildcard("Sent.%", "Sent.A.B"));
-    }
-}
diff --git a/src/imap/command/mod.rs b/src/imap/command/mod.rs
deleted file mode 100644
index f201eb6..0000000
--- a/src/imap/command/mod.rs
+++ /dev/null
@@ -1,20 +0,0 @@
-pub mod anonymous;
-pub mod anystate;
-pub mod authenticated;
-pub mod selected;
-
-use crate::mail::namespace::INBOX;
-use imap_codec::imap_types::mailbox::Mailbox as MailboxCodec;
-
-/// Convert an IMAP mailbox name/identifier representation
-/// to an utf-8 string that is used internally in Aerogramme
-struct MailboxName<'a>(&'a MailboxCodec<'a>);
-impl<'a> TryInto<&'a str> for MailboxName<'a> {
-    type Error = std::str::Utf8Error;
-    fn try_into(self) -> Result<&'a str, Self::Error> {
-        match self.0 {
-            MailboxCodec::Inbox => Ok(INBOX),
-            MailboxCodec::Other(aname) => Ok(std::str::from_utf8(aname.as_ref())?),
-        }
-    }
-}
diff --git a/src/imap/command/selected.rs b/src/imap/command/selected.rs
deleted file mode 100644
index eedfbd6..0000000
--- a/src/imap/command/selected.rs
+++ /dev/null
@@ -1,424 +0,0 @@
-use std::num::NonZeroU64;
-use std::sync::Arc;
-
-use anyhow::Result;
-use imap_codec::imap_types::command::{Command, CommandBody, FetchModifier, StoreModifier};
-use imap_codec::imap_types::core::{Charset, Vec1};
-use imap_codec::imap_types::fetch::MacroOrMessageDataItemNames;
-use imap_codec::imap_types::flag::{Flag, StoreResponse, StoreType};
-use imap_codec::imap_types::mailbox::Mailbox as MailboxCodec;
-use imap_codec::imap_types::response::{Code, CodeOther};
-use imap_codec::imap_types::search::SearchKey;
-use imap_codec::imap_types::sequence::SequenceSet;
-
-use crate::imap::attributes::AttributesProxy;
-use crate::imap::capability::{ClientCapability, ServerCapability};
-use crate::imap::command::{anystate, authenticated, MailboxName};
-use crate::imap::flow;
-use crate::imap::mailbox_view::{MailboxView, UpdateParameters};
-use crate::imap::response::Response;
-use crate::user::User;
-
-pub struct SelectedContext<'a> {
-    pub req: &'a Command<'static>,
-    pub user: &'a Arc<User>,
-    pub mailbox: &'a mut MailboxView,
-    pub server_capabilities: &'a ServerCapability,
-    pub client_capabilities: &'a mut ClientCapability,
-    pub perm: &'a flow::MailboxPerm,
-}
-
-pub async fn dispatch<'a>(
-    ctx: SelectedContext<'a>,
-) -> Result<(Response<'static>, flow::Transition)> {
-    match &ctx.req.body {
-        // Any State
-        // noop is specific to this state
-        CommandBody::Capability => {
-            anystate::capability(ctx.req.tag.clone(), ctx.server_capabilities)
-        }
-        CommandBody::Logout => anystate::logout(),
-
-        // Specific to this state (7 commands + NOOP)
-        CommandBody::Close => match ctx.perm {
-            flow::MailboxPerm::ReadWrite => ctx.close().await,
-            flow::MailboxPerm::ReadOnly => ctx.examine_close().await,
-        },
-        CommandBody::Noop | CommandBody::Check => ctx.noop().await,
-        CommandBody::Fetch {
-            sequence_set,
-            macro_or_item_names,
-            modifiers,
-            uid,
-        } => {
-            ctx.fetch(sequence_set, macro_or_item_names, modifiers, uid)
-                .await
-        }
-        //@FIXME SearchKey::And is a legacy hack, should be refactored
-        CommandBody::Search {
-            charset,
-            criteria,
-            uid,
-        } => {
-            ctx.search(charset, &SearchKey::And(criteria.clone()), uid)
-                .await
-        }
-        CommandBody::Expunge {
-            // UIDPLUS (rfc4315)
-            uid_sequence_set,
-        } => ctx.expunge(uid_sequence_set).await,
-        CommandBody::Store {
-            sequence_set,
-            kind,
-            response,
-            flags,
-            modifiers,
-            uid,
-        } => {
-            ctx.store(sequence_set, kind, response, flags, modifiers, uid)
-                .await
-        }
-        CommandBody::Copy {
-            sequence_set,
-            mailbox,
-            uid,
-        } => ctx.copy(sequence_set, mailbox, uid).await,
-        CommandBody::Move {
-            sequence_set,
-            mailbox,
-            uid,
-        } => ctx.r#move(sequence_set, mailbox, uid).await,
-
-        // UNSELECT extension (rfc3691)
-        CommandBody::Unselect => ctx.unselect().await,
-
-        // In selected mode, we fallback to authenticated when needed
-        _ => {
-            authenticated::dispatch(authenticated::AuthenticatedContext {
-                req: ctx.req,
-                server_capabilities: ctx.server_capabilities,
-                client_capabilities: ctx.client_capabilities,
-                user: ctx.user,
-            })
-            .await
-        }
-    }
-}
-
-// --- PRIVATE ---
-
-impl<'a> SelectedContext<'a> {
-    async fn close(self) -> Result<(Response<'static>, flow::Transition)> {
-        // We expunge messages,
-        // but we don't send the untagged EXPUNGE responses
-        let tag = self.req.tag.clone();
-        self.expunge(&None).await?;
-        Ok((
-            Response::build().tag(tag).message("CLOSE completed").ok()?,
-            flow::Transition::Unselect,
-        ))
-    }
-
-    /// CLOSE in examined state is not the same as in selected state
-    /// (in selected state it also does an EXPUNGE, here it doesn't)
-    async fn examine_close(self) -> Result<(Response<'static>, flow::Transition)> {
-        Ok((
-            Response::build()
-                .to_req(self.req)
-                .message("CLOSE completed")
-                .ok()?,
-            flow::Transition::Unselect,
-        ))
-    }
-
-    async fn unselect(self) -> Result<(Response<'static>, flow::Transition)> {
-        Ok((
-            Response::build()
-                .to_req(self.req)
-                .message("UNSELECT completed")
-                .ok()?,
-            flow::Transition::Unselect,
-        ))
-    }
-
-    pub async fn fetch(
-        self,
-        sequence_set: &SequenceSet,
-        attributes: &'a MacroOrMessageDataItemNames<'static>,
-        modifiers: &[FetchModifier],
-        uid: &bool,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let ap = AttributesProxy::new(attributes, modifiers, *uid);
-        let mut changed_since: Option<NonZeroU64> = None;
-        modifiers.iter().for_each(|m| match m {
-            FetchModifier::ChangedSince(val) => {
-                changed_since = Some(*val);
-            }
-        });
-
-        match self
-            .mailbox
-            .fetch(sequence_set, &ap, changed_since, uid)
-            .await
-        {
-            Ok(resp) => {
-                // Capabilities enabling logic only on successful command
-                // (according to my understanding of the spec)
-                self.client_capabilities.attributes_enable(&ap);
-                self.client_capabilities.fetch_modifiers_enable(modifiers);
-
-                // Response to the client
-                Ok((
-                    Response::build()
-                        .to_req(self.req)
-                        .message("FETCH completed")
-                        .set_body(resp)
-                        .ok()?,
-                    flow::Transition::None,
-                ))
-            }
-            Err(e) => Ok((
-                Response::build()
-                    .to_req(self.req)
-                    .message(e.to_string())
-                    .no()?,
-                flow::Transition::None,
-            )),
-        }
-    }
-
-    pub async fn search(
-        self,
-        charset: &Option<Charset<'a>>,
-        criteria: &SearchKey<'a>,
-        uid: &bool,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        let (found, enable_condstore) = self.mailbox.search(charset, criteria, *uid).await?;
-        if enable_condstore {
-            self.client_capabilities.enable_condstore();
-        }
-        Ok((
-            Response::build()
-                .to_req(self.req)
-                .set_body(found)
-                .message("SEARCH completed")
-                .ok()?,
-            flow::Transition::None,
-        ))
-    }
-
-    pub async fn noop(self) -> Result<(Response<'static>, flow::Transition)> {
-        self.mailbox.internal.mailbox.force_sync().await?;
-
-        let updates = self.mailbox.update(UpdateParameters::default()).await?;
-        Ok((
-            Response::build()
-                .to_req(self.req)
-                .message("NOOP completed.")
-                .set_body(updates)
-                .ok()?,
-            flow::Transition::None,
-        ))
-    }
-
-    async fn expunge(
-        self,
-        uid_sequence_set: &Option<SequenceSet>,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        if let Some(failed) = self.fail_read_only() {
-            return Ok((failed, flow::Transition::None));
-        }
-
-        let tag = self.req.tag.clone();
-        let data = self.mailbox.expunge(uid_sequence_set).await?;
-
-        Ok((
-            Response::build()
-                .tag(tag)
-                .message("EXPUNGE completed")
-                .set_body(data)
-                .ok()?,
-            flow::Transition::None,
-        ))
-    }
-
-    async fn store(
-        self,
-        sequence_set: &SequenceSet,
-        kind: &StoreType,
-        response: &StoreResponse,
-        flags: &[Flag<'a>],
-        modifiers: &[StoreModifier],
-        uid: &bool,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        if let Some(failed) = self.fail_read_only() {
-            return Ok((failed, flow::Transition::None));
-        }
-
-        let mut unchanged_since: Option<NonZeroU64> = None;
-        modifiers.iter().for_each(|m| match m {
-            StoreModifier::UnchangedSince(val) => {
-                unchanged_since = Some(*val);
-            }
-        });
-
-        let (data, modified) = self
-            .mailbox
-            .store(sequence_set, kind, response, flags, unchanged_since, uid)
-            .await?;
-
-        let mut ok_resp = Response::build()
-            .to_req(self.req)
-            .message("STORE completed")
-            .set_body(data);
-
-        match modified[..] {
-            [] => (),
-            [_head, ..] => {
-                let modified_str = format!(
-                    "MODIFIED {}",
-                    modified
-                        .into_iter()
-                        .map(|x| x.to_string())
-                        .collect::<Vec<_>>()
-                        .join(",")
-                );
-                ok_resp = ok_resp.code(Code::Other(CodeOther::unvalidated(
-                    modified_str.into_bytes(),
-                )));
-            }
-        };
-
-        self.client_capabilities.store_modifiers_enable(modifiers);
-
-        Ok((ok_resp.ok()?, flow::Transition::None))
-    }
-
-    async fn copy(
-        self,
-        sequence_set: &SequenceSet,
-        mailbox: &MailboxCodec<'a>,
-        uid: &bool,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        //@FIXME Could copy be valid in EXAMINE mode?
-        if let Some(failed) = self.fail_read_only() {
-            return Ok((failed, flow::Transition::None));
-        }
-
-        let name: &str = MailboxName(mailbox).try_into()?;
-
-        let mb_opt = self.user.open_mailbox(&name).await?;
-        let mb = match mb_opt {
-            Some(mb) => mb,
-            None => {
-                return Ok((
-                    Response::build()
-                        .to_req(self.req)
-                        .message("Destination mailbox does not exist")
-                        .code(Code::TryCreate)
-                        .no()?,
-                    flow::Transition::None,
-                ))
-            }
-        };
-
-        let (uidval, uid_map) = self.mailbox.copy(sequence_set, mb, uid).await?;
-
-        let copyuid_str = format!(
-            "{} {} {}",
-            uidval,
-            uid_map
-                .iter()
-                .map(|(sid, _)| format!("{}", sid))
-                .collect::<Vec<_>>()
-                .join(","),
-            uid_map
-                .iter()
-                .map(|(_, tuid)| format!("{}", tuid))
-                .collect::<Vec<_>>()
-                .join(",")
-        );
-
-        Ok((
-            Response::build()
-                .to_req(self.req)
-                .message("COPY completed")
-                .code(Code::Other(CodeOther::unvalidated(
-                    format!("COPYUID {}", copyuid_str).into_bytes(),
-                )))
-                .ok()?,
-            flow::Transition::None,
-        ))
-    }
-
-    async fn r#move(
-        self,
-        sequence_set: &SequenceSet,
-        mailbox: &MailboxCodec<'a>,
-        uid: &bool,
-    ) -> Result<(Response<'static>, flow::Transition)> {
-        if let Some(failed) = self.fail_read_only() {
-            return Ok((failed, flow::Transition::None));
-        }
-
-        let name: &str = MailboxName(mailbox).try_into()?;
-
-        let mb_opt = self.user.open_mailbox(&name).await?;
-        let mb = match mb_opt {
-            Some(mb) => mb,
-            None => {
-                return Ok((
-                    Response::build()
-                        .to_req(self.req)
-                        .message("Destination mailbox does not exist")
-                        .code(Code::TryCreate)
-                        .no()?,
-                    flow::Transition::None,
-                ))
-            }
-        };
-
-        let (uidval, uid_map, data) = self.mailbox.r#move(sequence_set, mb, uid).await?;
-
-        // compute code
-        let copyuid_str = format!(
-            "{} {} {}",
-            uidval,
-            uid_map
-                .iter()
-                .map(|(sid, _)| format!("{}", sid))
-                .collect::<Vec<_>>()
-                .join(","),
-            uid_map
-                .iter()
-                .map(|(_, tuid)| format!("{}", tuid))
-                .collect::<Vec<_>>()
-                .join(",")
-        );
-
-        Ok((
-            Response::build()
-                .to_req(self.req)
-                .message("COPY completed")
-                .code(Code::Other(CodeOther::unvalidated(
-                    format!("COPYUID {}", copyuid_str).into_bytes(),
-                )))
-                .set_body(data)
-                .ok()?,
-            flow::Transition::None,
-        ))
-    }
-
-    fn fail_read_only(&self) -> Option<Response<'static>> {
-        match self.perm {
-            flow::MailboxPerm::ReadWrite => None,
-            flow::MailboxPerm::ReadOnly => Some(
-                Response::build()
-                    .to_req(self.req)
-                    .message("Write command are forbidden while exmining mailbox")
-                    .no()
-                    .unwrap(),
-            ),
-        }
-    }
-}