fix: case sensitive tag filtering for A|B tags in /messages/tags query

Author: charmful0x

crates/server/src/indexer.rs

@@ -330,10 +330,17 @@ impl AtlasIndexerClient {
     pub async fn mainnet_messages_by_tag(
         &self,
         protocol: Option<&str>,
-        tag_key: &str,
+        tag_keys: &[String],
         tag_value: &str,
         limit: u64,
     ) -> Result<Vec<MainnetMessage>, Error> {
+        if tag_keys.is_empty() {
+            return Ok(Vec::new());
+        }
+        let placeholders = std::iter::repeat("?")
+            .take(tag_keys.len())
+            .collect::<Vec<_>>()
+            .join(", ");
         let protocol_clause = if protocol.is_some() {
             " and m.protocol = ?"
         } else {
@@ -349,17 +356,17 @@ impl AtlasIndexerClient {
                on filter.protocol = m.protocol and filter.block_height = m.block_height and filter.msg_id = m.msg_id \
              left join ao_mainnet_message_tags t \
                on t.protocol = m.protocol and t.block_height = m.block_height and t.msg_id = m.msg_id \
-             where filter.tag_key = ? and filter.tag_value = ?{} \
+             where filter.tag_key in ({}) and filter.tag_value = ?{} \
              group by m.protocol, m.block_height, m.block_timestamp, m.msg_id, m.owner, m.recipient, m.bundled_in, m.data_size, m.ts \
              order by m.block_height desc, m.msg_id desc \
              limit ?",
-            protocol_clause
+            placeholders, protocol_clause
         );
-        let mut query = self
-            .client
-            .query(&sql)
-            .bind(tag_key)
-            .bind(tag_value);
+        let mut query = self.client.query(&sql);
+        for key in tag_keys {
+            query = query.bind(key);
+        }
+        query = query.bind(tag_value);
         if let Some(p) = protocol {
             query = query.bind(p);
         }

crates/server/src/routes.rs

@@ -234,8 +234,12 @@ pub async fn get_mainnet_messages_by_tag(
         .filter(|v| !v.is_empty())
         .ok_or_else(|| ServerError::from(anyhow!("missing tag value")))?;
     let client = AtlasIndexerClient::new().await?;
+    let tag_keys = build_tag_key_variants(protocol.as_deref(), &key);
+    if tag_keys.is_empty() {
+        return Err(ServerError::from(anyhow!("invalid tag key")));
+    }
     let rows = client
-        .mainnet_messages_by_tag(protocol.as_deref(), &key, &value, limit)
+        .mainnet_messages_by_tag(protocol.as_deref(), &tag_keys, &value, limit)
         .await?;
     Ok(Json(serde_json::to_value(&rows)?))
 }
@@ -259,3 +263,40 @@ fn parse_protocol(value: Option<&String>) -> Result<Option<String>, ServerError>
     }
     Ok(None)
 }
+
+fn build_tag_key_variants(protocol: Option<&str>, key: &str) -> Vec<String> {
+    let trimmed = key.trim();
+    if trimmed.is_empty() {
+        return Vec::new();
+    }
+    let lower = trimmed.to_ascii_lowercase();
+    let header = to_header_case(trimmed);
+    match protocol {
+        Some("A") => vec![lower],
+        Some("B") => vec![header],
+        _ => {
+            if lower == header {
+                vec![lower]
+            } else {
+                vec![lower, header]
+            }
+        }
+    }
+}
+
+fn to_header_case(input: &str) -> String {
+    let mut result = String::with_capacity(input.len());
+    for (i, segment) in input.split('-').enumerate() {
+        if i > 0 {
+            result.push('-');
+        }
+        let mut chars = segment.chars();
+        if let Some(first) = chars.next() {
+            result.push(first.to_ascii_uppercase());
+        }
+        for c in chars {
+            result.push(c.to_ascii_lowercase());
+        }
+    }
+    result
+}