1use async_trait::async_trait;
2use serde::{Deserialize, Serialize};
3
4const GMAIL_API_BASE: &str = "https://gmail.googleapis.com/gmail/v1";
5
6#[derive(Debug, Serialize, Deserialize)]
7pub struct GmailMessage {
8 pub id: String,
9 #[serde(rename = "threadId")]
10 pub thread_id: String,
11}
12
13#[derive(Debug, Serialize, Deserialize)]
14pub struct GmailMessageListResponse {
15 pub messages: Option<Vec<GmailMessage>>,
16 pub next_page_token: Option<String>,
17 pub result_size_estimate: Option<u32>,
18}
19
20#[derive(Debug, Serialize, Deserialize)]
21pub struct GmailMessageHeader {
22 pub name: String,
23 pub value: String,
24}
25
26#[derive(Debug, Serialize, Deserialize)]
27pub struct GmailMessagePart {
28 #[serde(rename = "mimeType")]
29 pub mime_type: Option<String>,
30 pub filename: Option<String>,
31 pub headers: Option<Vec<GmailMessageHeader>>,
32 pub body: Option<GmailMessageBody>,
33 pub parts: Option<Vec<GmailMessagePart>>,
34}
35
36#[derive(Debug, Serialize, Deserialize)]
37pub struct GmailMessageBody {
38 pub data: Option<String>,
39 pub size: Option<u32>,
40}
41
42#[derive(Debug, Serialize, Deserialize)]
43pub struct GmailFullMessage {
44 pub id: String,
45 #[serde(rename = "threadId")]
46 pub thread_id: String,
47 pub label_ids: Option<Vec<String>>,
48 pub snippet: Option<String>,
49 pub payload: Option<GmailMessagePart>,
50 pub internal_date: Option<String>,
51}
52
53#[derive(Debug, Clone)]
54pub struct ParsedEmail {
55 pub provider_id: String,
56 pub subject: Option<String>,
57 pub from_email: Option<String>,
58 pub from_name: Option<String>,
59 pub received_at: Option<String>,
60 pub body_html: Option<String>,
61 pub body_text: Option<String>,
62 pub snippet: Option<String>,
63}
64
65#[async_trait]
66pub trait TokenProvider: Send + Sync {
67 async fn get_access_token(&self) -> Result<String, String>;
68}
69
70pub struct GmailClient {
71 http_client: reqwest::Client,
72 token_provider: Box<dyn TokenProvider>,
73}
74
75impl GmailClient {
76 pub fn builder() -> GmailClientBuilder {
77 GmailClientBuilder::new()
78 }
79
80 pub async fn fetch_messages(
81 &self,
82 max_results: Option<u32>,
83 ) -> Result<Vec<GmailMessage>, String> {
84 let access_token = self.token_provider.get_access_token().await?;
85
86 let max = max_results.unwrap_or(10);
87 let url = format!("{}/users/me/messages?maxResults={}", GMAIL_API_BASE, max);
88
89 let response = self
90 .http_client
91 .get(&url)
92 .bearer_auth(&access_token)
93 .send()
94 .await
95 .map_err(|e| format!("Failed to fetch messages: {}", e))?;
96
97 let status = response.status();
98 let response_text = response
99 .text()
100 .await
101 .map_err(|e| format!("Failed to read response: {}", e))?;
102
103 if !status.is_success() {
104 return Err(format!("Gmail API error ({}): {}", status, response_text));
105 }
106
107 let list_response: GmailMessageListResponse = serde_json::from_str(&response_text)
108 .map_err(|e| format!("Failed to parse message list: {}", e))?;
109
110 Ok(list_response.messages.unwrap_or_default())
111 }
112
113 pub async fn fetch_message(&self, message_id: &str) -> Result<GmailFullMessage, String> {
114 let access_token = self.token_provider.get_access_token().await?;
115
116 let url = format!("{}/users/me/messages/{}", GMAIL_API_BASE, message_id);
117
118 let response = self
119 .http_client
120 .get(&url)
121 .bearer_auth(&access_token)
122 .send()
123 .await
124 .map_err(|e| format!("Failed to fetch message: {}", e))?;
125
126 let status = response.status();
127 let response_text = response
128 .text()
129 .await
130 .map_err(|e| format!("Failed to read response: {}", e))?;
131
132 if !status.is_success() {
133 return Err(format!("Gmail API error ({}): {}", status, response_text));
134 }
135
136 serde_json::from_str(&response_text).map_err(|e| format!("Failed to parse message: {}", e))
137 }
138
139 pub fn parse_email(&self, message: &GmailFullMessage) -> Result<ParsedEmail, String> {
140 let mut parsed = ParsedEmail {
141 provider_id: message.id.clone(),
142 subject: None,
143 from_email: None,
144 from_name: None,
145 received_at: message.internal_date.clone(),
146 body_html: None,
147 body_text: None,
148 snippet: message.snippet.clone(),
149 };
150
151 if let Some(ref payload) = message.payload {
152 if let Some(ref headers) = payload.headers {
154 for header in headers {
155 match header.name.as_str() {
156 "Subject" => parsed.subject = Some(header.value.clone()),
157 "From" => {
158 let from = parse_from_header(&header.value);
159 parsed.from_email = from.0;
160 parsed.from_name = from.1;
161 }
162 "Date" => {
163 if parsed.received_at.is_none() {
164 parsed.received_at = Some(header.value.clone());
165 }
166 }
167 _ => {}
168 }
169 }
170 }
171
172 extract_body(payload, &mut parsed);
174 }
175
176 Ok(parsed)
177 }
178}
179
180pub struct GmailClientBuilder {
181 http_client: Option<reqwest::Client>,
182 token_provider: Option<Box<dyn TokenProvider>>,
183}
184
185impl GmailClientBuilder {
186 pub fn new() -> Self {
187 Self {
188 http_client: None,
189 token_provider: None,
190 }
191 }
192
193 pub fn http_client(mut self, client: reqwest::Client) -> Self {
194 self.http_client = Some(client);
195 self
196 }
197
198 pub fn token_provider(mut self, provider: Box<dyn TokenProvider>) -> Self {
199 self.token_provider = Some(provider);
200 self
201 }
202
203 pub fn build(self) -> Result<GmailClient, String> {
204 let http_client = self.http_client.unwrap_or_else(|| reqwest::Client::new());
205 let token_provider = self.token_provider.ok_or("Token provider is required")?;
206
207 Ok(GmailClient {
208 http_client,
209 token_provider,
210 })
211 }
212}
213
214fn parse_from_header(from: &str) -> (Option<String>, Option<String>) {
215 if let Some(start) = from.find('<') {
217 if let Some(end) = from.find('>') {
218 let email = from[start + 1..end].trim().to_string();
219 let name = from[..start].trim().trim_matches('"').to_string();
220 return (Some(email), if name.is_empty() { None } else { Some(name) });
221 }
222 }
223
224 (Some(from.trim().to_string()), None)
226}
227
228fn extract_body(part: &GmailMessagePart, parsed: &mut ParsedEmail) {
229 if let Some(ref parts) = part.parts {
230 for p in parts {
231 extract_body(p, parsed);
232 }
233 }
234
235 if let Some(ref body) = part.body {
236 if let Some(ref data) = body.data {
237 use base64::{engine::general_purpose, Engine as _};
238 let decoded = general_purpose::STANDARD
239 .decode(data.replace("-", "+").replace("_", "/"))
240 .ok()
241 .and_then(|bytes| String::from_utf8(bytes).ok());
242
243 if let Some(decoded) = decoded {
244 match part.mime_type.as_deref() {
245 Some("text/html") => {
246 parsed.body_html = Some(decoded);
247 }
248 Some("text/plain") => {
249 parsed.body_text = Some(decoded);
250 }
251 _ => {}
252 }
253 }
254 }
255 }
256}