fix(gmail): refactor shared reply-forward helpers

Author: HeroSizy

src/helpers/gmail/forward.rs

@@ -24,15 +24,15 @@ pub(super) async fn handle_forward(
 
     let (original, token) = if dry_run {
         (
-            super::reply::OriginalMessage::dry_run_placeholder(&config.message_id),
+            OriginalMessage::dry_run_placeholder(&config.message_id),
             None,
         )
     } else {
         let t = auth::get_token(&[GMAIL_SCOPE])
             .await
             .map_err(|e| GwsError::Auth(format!("Gmail auth failed: {e}")))?;
         let client = crate::client::build_client()?;
-        let orig = super::reply::fetch_message_metadata(&client, &t, &config.message_id).await?;
+        let orig = fetch_message_metadata(&client, &t, &config.message_id).await?;
         (orig, Some(t))
     };
 
@@ -71,7 +71,7 @@ fn create_forward_raw_message(
     from: Option<&str>,
     subject: &str,
     body: Option<&str>,
-    original: &super::reply::OriginalMessage,
+    original: &OriginalMessage,
 ) -> String {
     let mut headers = format!(
         "To: {}\r\nSubject: {}\r\nMIME-Version: 1.0\r\nContent-Type: text/plain; charset=utf-8",
@@ -94,7 +94,7 @@ fn create_forward_raw_message(
     }
 }
 
-fn format_forwarded_message(original: &super::reply::OriginalMessage) -> String {
+fn format_forwarded_message(original: &OriginalMessage) -> String {
     format!(
         "---------- Forwarded message ---------\r\n\
          From: {}\r\n\
@@ -147,7 +147,7 @@ mod tests {
 
     #[test]
     fn test_create_forward_raw_message_without_body() {
-        let original = super::super::reply::OriginalMessage {
+        let original = super::super::OriginalMessage {
             thread_id: "t1".to_string(),
             message_id_header: "<abc@example.com>".to_string(),
             references: "".to_string(),
@@ -178,7 +178,7 @@ mod tests {
 
     #[test]
     fn test_create_forward_raw_message_with_body_and_cc() {
-        let original = super::super::reply::OriginalMessage {
+        let original = super::super::OriginalMessage {
             thread_id: "t1".to_string(),
             message_id_header: "<abc@example.com>".to_string(),
             references: "".to_string(),

src/helpers/gmail/mod.rs

@@ -40,6 +40,203 @@ pub struct GmailHelper;
 pub(super) const GMAIL_SCOPE: &str = "https://www.googleapis.com/auth/gmail.modify";
 pub(super) const PUBSUB_SCOPE: &str = "https://www.googleapis.com/auth/pubsub";
 
+pub(super) struct OriginalMessage {
+    pub thread_id: String,
+    pub message_id_header: String,
+    pub references: String,
+    pub from: String,
+    pub reply_to: String,
+    pub to: String,
+    pub cc: String,
+    pub subject: String,
+    pub date: String,
+    pub body_text: String,
+}
+
+impl OriginalMessage {
+    /// Placeholder used for `--dry-run` to avoid requiring auth/network.
+    pub(super) fn dry_run_placeholder(message_id: &str) -> Self {
+        Self {
+            thread_id: format!("thread-{message_id}"),
+            message_id_header: format!("<{message_id}@example.com>"),
+            references: String::new(),
+            from: "sender@example.com".to_string(),
+            reply_to: String::new(),
+            to: "you@example.com".to_string(),
+            cc: String::new(),
+            subject: "Original subject".to_string(),
+            date: "Thu, 1 Jan 2026 00:00:00 +0000".to_string(),
+            body_text: "Original message body".to_string(),
+        }
+    }
+}
+
+#[derive(Default)]
+struct ParsedMessageHeaders {
+    from: String,
+    reply_to: String,
+    to: String,
+    cc: String,
+    subject: String,
+    date: String,
+    message_id_header: String,
+    references: String,
+}
+
+fn append_header_value(existing: &mut String, value: &str) {
+    if !existing.is_empty() {
+        existing.push(' ');
+    }
+    existing.push_str(value);
+}
+
+fn parse_message_headers(headers: &[Value]) -> ParsedMessageHeaders {
+    let mut parsed = ParsedMessageHeaders::default();
+
+    for header in headers {
+        let name = header.get("name").and_then(|v| v.as_str()).unwrap_or("");
+        let value = header.get("value").and_then(|v| v.as_str()).unwrap_or("");
+
+        match name {
+            "From" => parsed.from = value.to_string(),
+            "Reply-To" => parsed.reply_to = value.to_string(),
+            "To" => parsed.to = value.to_string(),
+            "Cc" => parsed.cc = value.to_string(),
+            "Subject" => parsed.subject = value.to_string(),
+            "Date" => parsed.date = value.to_string(),
+            "Message-ID" | "Message-Id" => parsed.message_id_header = value.to_string(),
+            "References" => append_header_value(&mut parsed.references, value),
+            _ => {}
+        }
+    }
+
+    parsed
+}
+
+fn parse_original_message(msg: &Value) -> OriginalMessage {
+    let thread_id = msg
+        .get("threadId")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+
+    let snippet = msg
+        .get("snippet")
+        .and_then(|v| v.as_str())
+        .unwrap_or("")
+        .to_string();
+
+    let parsed_headers = msg
+        .get("payload")
+        .and_then(|p| p.get("headers"))
+        .and_then(|h| h.as_array())
+        .map(|headers| parse_message_headers(headers))
+        .unwrap_or_default();
+
+    let body_text = msg
+        .get("payload")
+        .and_then(extract_plain_text_body)
+        .unwrap_or(snippet);
+
+    OriginalMessage {
+        thread_id,
+        message_id_header: parsed_headers.message_id_header,
+        references: parsed_headers.references,
+        from: parsed_headers.from,
+        reply_to: parsed_headers.reply_to,
+        to: parsed_headers.to,
+        cc: parsed_headers.cc,
+        subject: parsed_headers.subject,
+        date: parsed_headers.date,
+        body_text,
+    }
+}
+
+pub(super) async fn fetch_message_metadata(
+    client: &reqwest::Client,
+    token: &str,
+    message_id: &str,
+) -> Result<OriginalMessage, GwsError> {
+    let url = format!(
+        "https://gmail.googleapis.com/gmail/v1/users/me/messages/{}",
+        crate::validate::encode_path_segment(message_id)
+    );
+
+    let resp = crate::client::send_with_retry(|| {
+        client
+            .get(&url)
+            .bearer_auth(token)
+            .query(&[("format", "full")])
+    })
+    .await
+    .map_err(|e| GwsError::Other(anyhow::anyhow!("Failed to fetch message: {e}")))?;
+
+    if !resp.status().is_success() {
+        let status = resp.status().as_u16();
+        let err = resp.text().await.unwrap_or_default();
+        return Err(GwsError::Api {
+            code: status,
+            message: format!("Failed to fetch message {message_id}: {err}"),
+            reason: "fetchFailed".to_string(),
+            enable_url: None,
+        });
+    }
+
+    let msg: Value = resp
+        .json()
+        .await
+        .map_err(|e| GwsError::Other(anyhow::anyhow!("Failed to parse message: {e}")))?;
+
+    Ok(parse_original_message(&msg))
+}
+
+fn extract_plain_text_body(payload: &Value) -> Option<String> {
+    let mime_type = payload
+        .get("mimeType")
+        .and_then(|v| v.as_str())
+        .unwrap_or("");
+
+    if mime_type == "text/plain" {
+        if let Some(data) = payload
+            .get("body")
+            .and_then(|b| b.get("data"))
+            .and_then(|d| d.as_str())
+        {
+            if let Ok(decoded) = URL_SAFE.decode(data) {
+                return String::from_utf8(decoded).ok();
+            }
+        }
+        return None;
+    }
+
+    if let Some(parts) = payload.get("parts").and_then(|p| p.as_array()) {
+        for part in parts {
+            if let Some(text) = extract_plain_text_body(part) {
+                return Some(text);
+            }
+        }
+    }
+
+    None
+}
+
+pub(super) fn resolve_send_method(
+    doc: &crate::discovery::RestDescription,
+) -> Result<&crate::discovery::RestMethod, GwsError> {
+    let users_res = doc
+        .resources
+        .get("users")
+        .ok_or_else(|| GwsError::Discovery("Resource 'users' not found".to_string()))?;
+    let messages_res = users_res
+        .resources
+        .get("messages")
+        .ok_or_else(|| GwsError::Discovery("Resource 'users.messages' not found".to_string()))?;
+    messages_res
+        .methods
+        .get("send")
+        .ok_or_else(|| GwsError::Discovery("Method 'users.messages.send' not found".to_string()))
+}
+
 /// Shared helper: base64-encode a raw RFC 2822 message and send it via
 /// `users.messages.send`, optionally keeping it in the given thread.
 pub(super) fn build_raw_send_body(raw_message: &str, thread_id: Option<&str>) -> Value {
@@ -63,7 +260,7 @@ pub(super) async fn send_raw_email(
     let body = build_raw_send_body(raw_message, thread_id);
     let body_str = body.to_string();
 
-    let send_method = reply::resolve_send_method(doc)?;
+    let send_method = resolve_send_method(doc)?;
     let params = json!({ "userId": "me" });
     let params_str = params.to_string();
 
@@ -479,6 +676,7 @@ TIPS:
 #[cfg(test)]
 mod tests {
     use super::*;
+    use std::collections::HashMap;
 
     #[test]
     fn test_inject_commands() {
@@ -511,4 +709,68 @@ mod tests {
         assert_eq!(body["raw"], URL_SAFE.encode("raw message"));
         assert!(body.get("threadId").is_none());
     }
+
+    #[test]
+    fn test_parse_original_message_concatenates_repeated_references_headers() {
+        let msg = json!({
+            "threadId": "thread-123",
+            "snippet": "Snippet fallback",
+            "payload": {
+                "mimeType": "text/html",
+                "headers": [
+                    { "name": "From", "value": "alice@example.com" },
+                    { "name": "Reply-To", "value": "team@example.com" },
+                    { "name": "To", "value": "bob@example.com" },
+                    { "name": "Cc", "value": "carol@example.com" },
+                    { "name": "Subject", "value": "Hello" },
+                    { "name": "Date", "value": "Fri, 6 Mar 2026 12:00:00 +0000" },
+                    { "name": "Message-ID", "value": "<msg@example.com>" },
+                    { "name": "References", "value": "<ref-1@example.com>" },
+                    { "name": "References", "value": "<ref-2@example.com>" }
+                ],
+                "body": {
+                    "data": URL_SAFE.encode("<p>HTML only</p>")
+                }
+            }
+        });
+
+        let original = parse_original_message(&msg);
+
+        assert_eq!(original.thread_id, "thread-123");
+        assert_eq!(original.from, "alice@example.com");
+        assert_eq!(original.reply_to, "team@example.com");
+        assert_eq!(original.to, "bob@example.com");
+        assert_eq!(original.cc, "carol@example.com");
+        assert_eq!(original.subject, "Hello");
+        assert_eq!(original.date, "Fri, 6 Mar 2026 12:00:00 +0000");
+        assert_eq!(original.message_id_header, "<msg@example.com>");
+        assert_eq!(
+            original.references,
+            "<ref-1@example.com> <ref-2@example.com>"
+        );
+        assert_eq!(original.body_text, "Snippet fallback");
+    }
+
+    #[test]
+    fn test_resolve_send_method_finds_gmail_send_method() {
+        let mut doc = crate::discovery::RestDescription::default();
+        let send_method = crate::discovery::RestMethod {
+            http_method: "POST".to_string(),
+            path: "gmail/v1/users/{userId}/messages/send".to_string(),
+            ..Default::default()
+        };
+
+        let mut messages = crate::discovery::RestResource::default();
+        messages.methods.insert("send".to_string(), send_method);
+
+        let mut users = crate::discovery::RestResource::default();
+        users.resources.insert("messages".to_string(), messages);
+
+        doc.resources = HashMap::from([("users".to_string(), users)]);
+
+        let resolved = resolve_send_method(&doc).unwrap();
+
+        assert_eq!(resolved.http_method, "POST");
+        assert_eq!(resolved.path, "gmail/v1/users/{userId}/messages/send");
+    }
 }