Imap::new() accepting login params

Author: link2xt

src/configure.rs

@@ -530,15 +530,11 @@ async fn configure(ctx: &Context, param: &EnteredLoginParam) -> Result<Option<&'
     let transport_id = 0;
     let (_s, r) = async_channel::bounded(1);
     let mut imap = Imap::new(
+        ctx,
         transport_id,
-        configured_param.imap.clone(),
-        configured_param.imap_password.clone(),
-        proxy_config,
-        &configured_param.addr,
-        strict_tls,
-        configured_param.oauth2,
+        configured_param.clone(),
         r,
-    );
+    ).await?;
     let configuring = true;
     let mut imap_session = match imap.connect(ctx, configuring).await {
         Ok(session) => session,

src/imap.rs

@@ -248,20 +248,19 @@ impl<T: Iterator<Item = (i64, u32, String)>> Iterator for UidGrouper<T> {
 
 impl Imap {
     /// Creates new disconnected IMAP client using the specific login parameters.
-    ///
-    /// `addr` is used to renew token if OAuth2 authentication is used.
-    #[expect(clippy::too_many_arguments)]
-    pub fn new(
+    pub async fn new(
+        context: &Context,
         transport_id: u32,
-        lp: Vec<ConfiguredServerLoginParam>,
-        password: String,
-        proxy_config: Option<ProxyConfig>,
-        addr: &str,
-        strict_tls: bool,
-        oauth2: bool,
+        param: ConfiguredLoginParam,
         idle_interrupt_receiver: Receiver<()>,
-    ) -> Self {
-        Imap {
+    ) -> Result<Self> {
+        let lp = param.imap.clone();
+        let password = param.imap_password.clone();
+        let proxy_config = ProxyConfig::load(context).await?;
+        let addr = &param.addr;
+        let strict_tls = param.strict_tls(proxy_config.is_some());
+        let oauth2 = param.oauth2;
+        Ok( Imap {
             transport_id,
             idle_interrupt_receiver,
             addr: addr.to_string(),
@@ -276,7 +275,7 @@ impl Imap {
             conn_backoff_ms: 0,
             // 1 connection per minute + a burst of 2.
             ratelimit: Ratelimit::new(Duration::new(120, 0), 2.0),
-        }
+        })
     }
 
     /// Creates new disconnected IMAP client using configured parameters.
@@ -287,18 +286,7 @@ impl Imap {
         let (transport_id, param) = ConfiguredLoginParam::load(context)
             .await?
             .context("Not configured")?;
-        let proxy_config = ProxyConfig::load(context).await?;
-        let strict_tls = param.strict_tls(proxy_config.is_some());
-        let imap = Self::new(
-            transport_id,
-            param.imap.clone(),
-            param.imap_password.clone(),
-            proxy_config,
-            &param.addr,
-            strict_tls,
-            param.oauth2,
-            idle_interrupt_receiver,
-        );
+        let imap = Self::new(context, transport_id, param, idle_interrupt_receiver).await?;
         Ok(imap)
     }
 

src/scheduler.rs

@@ -27,6 +27,7 @@ use crate::smtp::{Smtp, send_smtp_messages};
 use crate::sql;
 use crate::stats::maybe_send_stats;
 use crate::tools::{self, duration_to_str, maybe_add_time_based_warnings, time, time_elapsed};
+use crate::transport::ConfiguredLoginParam;
 use crate::{constants, stats};
 
 pub(crate) mod connectivity;
@@ -862,7 +863,11 @@ impl Scheduler {
         let mut oboxes = Vec::new();
         let mut start_recvs = Vec::new();
 
-        let (conn_state, inbox_handlers) = ImapConnectionState::new(ctx).await?;
+        let (transport_id, configured_login_param) = ConfiguredLoginParam::load(ctx)
+            .await?
+            .context("Not configured")?;
+        let (conn_state, inbox_handlers) =
+            ImapConnectionState::new(ctx, transport_id, configured_login_param.clone()).await?;
         let (inbox_start_send, inbox_start_recv) = oneshot::channel();
         let handle = {
             let ctx = ctx.clone();
@@ -876,7 +881,7 @@ impl Scheduler {
         start_recvs.push(inbox_start_recv);
 
         if ctx.should_watch_mvbox().await? {
-            let (conn_state, handlers) = ImapConnectionState::new(ctx).await?;
+            let (conn_state, handlers) = ImapConnectionState::new(ctx, transport_id, configured_login_param).await?;
             let (start_send, start_recv) = oneshot::channel();
             let ctx = ctx.clone();
             let meaning = FolderMeaning::Mvbox;
@@ -1097,12 +1102,17 @@ pub(crate) struct ImapConnectionState {
 
 impl ImapConnectionState {
     /// Construct a new connection.
-    async fn new(context: &Context) -> Result<(Self, ImapConnectionHandlers)> {
+    async fn new(
+        context: &Context,
+        transport_id: u32,
+        login_param: ConfiguredLoginParam,
+    ) -> Result<(Self, ImapConnectionHandlers)> {
         let stop_token = CancellationToken::new();
         let (idle_interrupt_sender, idle_interrupt_receiver) = channel::bounded(1);
 
         let handlers = ImapConnectionHandlers {
-            connection: Imap::new_configured(context, idle_interrupt_receiver).await?,
+            connection: Imap::new(context, transport_id, login_param, idle_interrupt_receiver)
+                .await?,
             stop_token: stop_token.clone(),
         };
 

src/transport.rs

@@ -265,20 +265,14 @@ impl ConfiguredLoginParam {
     }
 
     /// Loads configured login parameters for all transports.
-    pub(crate) async fn load_all(context: &Context) -> Result<Vec<(u32, ConfiguredLoginParam)>> {
+    pub(crate) async fn load_all(context: &Context) -> Result<Vec<(u32, Self)>> {
         context
             .sql
-            .query_map("SELECT id, configured_param FROM transports", (), |row| {
+            .query_map_vec("SELECT id, configured_param FROM transports", (), |row| {
                 let id: u32 = row.get(0)?;
                 let json: String = row.get(1)?;
-                Ok((id, json))
-            }, |rows| {
-                let mut res = Vec::new();
-                for row in rows {
-                    let (id, json) = row?;
-                    res.push((id, Self::from_json(&json)?));
-                }
-                Ok(res)
+                let param = Self::from_json(&json)?;
+                Ok((id, param))
             })
             .await
     }