refactor(workspace): decompose project into multiple crates

crates/core/src/autoconfig/entity.rs

@@ -0,0 +1,77 @@
+//
+// Copyright (c) 2025-2026 rustmailer.com (https://rustmailer.com)
+//
+// This file is part of the Bichon Email Archiving Project
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+use autoconfig::config::OAuth2Config as XOAuth2Config;
+use serde::{Deserialize, Serialize};
+
+use crate::account::entity::Encryption;
+
+#[derive(Debug, Clone, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "web-api", derive(poem_openapi::Object))]
+pub struct ServerConfig {
+    /// server hostname or IP address
+    pub host: String,
+    /// server port number
+    pub port: u16,
+    /// Connection encryption method
+    pub encryption: Encryption,
+}
+
+impl ServerConfig {
+    pub fn new(host: String, port: u16, encryption: Encryption) -> Self {
+        Self {
+            host,
+            port,
+            encryption,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "web-api", derive(poem_openapi::Object))]
+pub struct OAuth2Config {
+    /// The authorization server's issuer identifier URL
+    pub issuer: String,
+    /// List of scopes requested by the client
+    pub scope: Vec<String>,
+    /// URL of the authorization server's authorization endpoint
+    pub auth_url: String,
+    /// URL of the authorization server's token endpoint
+    pub token_url: String,
+}
+
+impl From<&XOAuth2Config> for OAuth2Config {
+    fn from(value: &XOAuth2Config) -> Self {
+        Self {
+            issuer: value.issuer().into(),
+            scope: value.scope().into_iter().map(Into::into).collect(),
+            auth_url: value.auth_url().into(),
+            token_url: value.token_url().into(),
+        }
+    }
+}
+
+#[derive(Debug, Clone, Default, Eq, PartialEq, Serialize, Deserialize)]
+#[cfg_attr(feature = "web-api", derive(poem_openapi::Object))]
+pub struct MailServerConfig {
+    /// IMAP server configuration
+    pub imap: ServerConfig,
+    /// OAuth 2.0 client configuration parameters
+    pub oauth2: Option<OAuth2Config>,
+}

crates/core/src/autoconfig/load.rs

@@ -0,0 +1,114 @@
+//
+// Copyright (c) 2025-2026 rustmailer.com (https://rustmailer.com)
+//
+// This file is part of the Bichon Email Archiving Project
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+use crate::autoconfig::entity::{MailServerConfig, ServerConfig};
+use crate::error::code::ErrorCode;
+use crate::{
+    {
+        account::entity::Encryption, autoconfig::CachedMailSettings, error::BichonResult,
+    },
+    raise_error,
+};
+use autoconfig::config::{Server, ServerType};
+use email_address::EmailAddress;
+use std::str::FromStr;
+use tracing::error;
+
+pub async fn resolve_autoconfig(
+    email: impl AsRef<str>,
+) -> BichonResult<Option<MailServerConfig>> {
+    let email = email.as_ref();
+    let email_address = EmailAddress::from_str(email).map_err(|error| {
+        raise_error!(
+            format!("Invalid email address: {email:#?}. {error:#?}"),
+            ErrorCode::InvalidParameter
+        )
+    })?;
+
+    let domain = email_address.domain();
+    // try read local cache first
+    if let Some(cached_entity) = CachedMailSettings::get(domain).await? {
+        return Ok(Some(cached_entity.config));
+    }
+
+    let config = autoconfig::from_addr(email_address.email().as_ref())
+        .await
+        .map_err(|e| {
+            error!(email = %email, domain = %domain, error = ?e, "Autoconfig fetch failed");
+            raise_error!(
+                format!(
+                    "Failed to fetch autoconfig for email '{}': {:#?}",
+                    email_address.email(),
+                    e
+                ),
+                ErrorCode::AutoconfigFetchFailed
+            )
+        })?;
+
+    let imap_server = config
+        .email_provider()
+        .incoming_servers()
+        .into_iter()
+        .find(|s| matches!(s.server_type(), ServerType::Imap));
+    
+    let imap_server = match imap_server {
+        Some(imap) => imap,
+        None => return Ok(None),
+    };
+    
+    let get_encryption = |server: &Server| {
+        server
+            .security_type()
+            .map_or(Encryption::None, |encryption| match encryption {
+                autoconfig::config::SecurityType::Plain => Encryption::None,
+                autoconfig::config::SecurityType::Starttls => Encryption::StartTls,
+                autoconfig::config::SecurityType::Tls => Encryption::Ssl,
+            })
+    };
+
+    let get_port = |server: &Server, encryption: &Encryption, tls_port: u16, non_tls_port: u16| {
+        server.port().map_or_else(
+            || match encryption {
+                Encryption::StartTls => tls_port,
+                _ => non_tls_port,
+            },
+            ToOwned::to_owned,
+        )
+    };
+
+    let get_hostname = |server: &Server, default_prefix: &str| {
+        server.hostname().map_or_else(
+            || format!("{}.{}", default_prefix, domain),
+            ToOwned::to_owned,
+        )
+    };
+
+    let imap_encryption = get_encryption(imap_server);
+    let imap_config = ServerConfig::new(
+        get_hostname(imap_server, "imap"),
+        get_port(imap_server, &imap_encryption, 993, 143),
+        imap_encryption,
+    );
+    let result = MailServerConfig {
+        imap: imap_config,
+        oauth2: config.oauth2().map(|f| f.into()),
+    };
+    CachedMailSettings::add(domain.into(), result.clone()).await?;
+    Ok(Some(result))
+}

crates/core/src/autoconfig/mod.rs

@@ -0,0 +1,86 @@
+//
+// Copyright (c) 2025-2026 rustmailer.com (https://rustmailer.com)
+//
+// This file is part of the Bichon Email Archiving Project
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+use crate::database::manager::DB_MANAGER;
+use crate::database::{delete_impl, async_find_impl, upsert_impl};
+use crate::error::code::ErrorCode;
+use crate::raise_error;
+use crate::{
+    autoconfig::entity::MailServerConfig, error::BichonResult, utc_now,
+};
+use native_db::*;
+use native_model::{native_model, Model};
+use serde::{Deserialize, Serialize};
+
+pub mod entity;
+pub mod load;
+#[cfg(test)]
+mod tests;
+
+const EXPIRE_TIME_MS: i64 = 30 * 24 * 60 * 60 * 1000;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq, Deserialize, Serialize)]
+#[native_model(id = 3, version = 1)]
+#[native_db]
+pub struct CachedMailSettings {
+    #[primary_key]
+    pub domain: String,
+    pub config: MailServerConfig,
+    pub created_at: i64,
+}
+
+impl CachedMailSettings {
+    pub async fn add(domain: String, config: MailServerConfig) -> BichonResult<()> {
+        Self {
+            domain,
+            config,
+            created_at: utc_now!(),
+        }
+        .save()
+        .await
+    }
+
+    async fn save(&self) -> BichonResult<()> {
+        upsert_impl(DB_MANAGER.meta_db(), self.to_owned()).await
+    }
+
+    pub async fn get(domain: &str) -> BichonResult<Option<CachedMailSettings>> {
+        if let Some(found) =
+            async_find_impl::<CachedMailSettings>(DB_MANAGER.meta_db(), domain.to_string()).await?
+        {
+            if (utc_now!() - found.created_at) > EXPIRE_TIME_MS {
+                let domain = domain.to_string();
+                delete_impl(DB_MANAGER.meta_db(), |rw| {
+                    rw.get()
+                        .primary::<CachedMailSettings>(domain)
+                        .map_err(|e| raise_error!(format!("{:#?}", e), ErrorCode::InternalError))?
+                        .ok_or_else(|| {
+                            raise_error!("auto config cache miss".into(), ErrorCode::InternalError)
+                        })
+                })
+                .await?;
+                Ok(None)
+            } else {
+                Ok(Some(found))
+            }
+        } else {
+            Ok(None)
+        }
+    }
+}

crates/core/src/autoconfig/tests.rs

@@ -0,0 +1,24 @@
+//
+// Copyright (c) 2025-2026 rustmailer.com (https://rustmailer.com)
+//
+// This file is part of the Bichon Email Archiving Project
+//
+// This program is free software: you can redistribute it and/or modify
+// it under the terms of the GNU Affero General Public License as published by
+// the Free Software Foundation, either version 3 of the License, or
+// (at your option) any later version.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU Affero General Public License for more details.
+//
+// You should have received a copy of the GNU Affero General Public License
+// along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+#[tokio::test]
+async fn test() {
+    let config = autoconfig::from_addr("test@gmail.com").await.unwrap();
+    println!("{:#?}", config);
+}