remove a-label only restriction on cli, add a-label query type

icann-rdap-cli/src/main.rs

@@ -240,6 +240,9 @@ enum QtypeArg {
     /// Domain Lookup
     Domain,
 
+    /// A-Label Domain Lookup
+    ALabel,
+
     /// Entity Lookup
     Entity,
 
@@ -520,6 +523,7 @@ fn query_type_from_cli(cli: &Cli) -> QueryType {
                 QtypeArg::V6Cidr => QueryType::IpV6Cidr(query_value),
                 QtypeArg::Autnum => QueryType::AsNumber(query_value),
                 QtypeArg::Domain => QueryType::Domain(query_value),
+                QtypeArg::ALabel => QueryType::ALable(query_value),
                 QtypeArg::Entity => QueryType::Entity(query_value),
                 QtypeArg::Ns => QueryType::Nameserver(query_value),
                 QtypeArg::EntityName => QueryType::EntityNameSearch(query_value),

icann-rdap-cli/tests/integration/queries.rs

@@ -12,6 +12,7 @@ use crate::test_jig::TestJig;
 #[case("foo.example", "foo.example")]
 #[case("foo.example", "foo.example.")]
 #[case("foo.example", "FOO.EXAMPLE")]
+#[case("foó.example", "foó.example")] // unicode
 #[tokio::test(flavor = "multi_thread")]
 async fn GIVEN_domain_WHEN_query_THEN_success(#[case] db_domain: &str, #[case] q_domain: &str) {
     // GIVEN
@@ -156,3 +157,21 @@ async fn GIVEN_url_WHEN_query_THEN_success() {
     let assert = test_jig.cmd.assert();
     assert.success();
 }
+
+#[tokio::test(flavor = "multi_thread")]
+async fn GIVEN_idn_WHEN_query_a_label_THEN_success() {
+    // GIVEN
+    let mut test_jig = TestJig::new().await;
+    let mut tx = test_jig.mem.new_tx().await.expect("new transaction");
+    tx.add_domain(&Domain::basic().ldh_name("xn--caf-dma.example").build())
+        .await
+        .expect("add domain in tx");
+    tx.commit().await.expect("tx commit");
+
+    // WHEN
+    test_jig.cmd.arg("-t").arg("a-label").arg("café.example");
+
+    // THEN
+    let assert = test_jig.cmd.assert();
+    assert.success();
+}

icann-rdap-client/Cargo.toml

@@ -16,6 +16,7 @@ buildstructor.workspace = true
 cidr-utils.workspace = true
 chrono.workspace = true
 const_format.workspace = true
+idna.workspace = true
 lazy_static.workspace = true
 pct-str.workspace = true
 regex.workspace = true

icann-rdap-client/src/query/qtype.rs

@@ -1,6 +1,7 @@
 use std::{net::IpAddr, str::FromStr};
 
 use cidr_utils::cidr::IpInet;
+use icann_rdap_common::check::string::StringCheck;
 use lazy_static::lazy_static;
 use pct_str::{PctString, URIReserved};
 use regex::Regex;
@@ -29,6 +30,9 @@ pub enum QueryType {
     #[strum(serialize = "Domain Lookup")]
     Domain(String),
 
+    #[strum(serialize = "A-Label Domain Lookup")]
+    ALable(String),
+
     #[strum(serialize = "Entity Lookup")]
     Entity(String),
 
@@ -89,6 +93,7 @@ impl QueryType {
                 "{base_url}/domain/{}",
                 PctString::encode(value.chars(), URIReserved)
             )),
+            QueryType::ALable(value) => a_label_query(value, base_url),
             QueryType::Entity(value) => Ok(format!(
                 "{base_url}/entity/{}",
                 PctString::encode(value.chars(), URIReserved)
@@ -116,6 +121,14 @@ impl QueryType {
     }
 }
 
+fn a_label_query(value: &str, base_url: &str) -> Result<String, RdapClientError> {
+    let domain = idna::domain_to_ascii(value).map_err(|_| RdapClientError::InvalidQueryValue)?;
+    Ok(format!(
+        "{base_url}/domain/{}",
+        PctString::encode(domain.chars(), URIReserved),
+    ))
+}
+
 fn ip_cidr_query(value: &str, base_url: &str) -> Result<String, RdapClientError> {
     let values = value
         .split_once('/')
@@ -167,7 +180,7 @@ impl FromStr for QueryType {
         }
 
         // if it looks like a domain name
-        if is_ldh_domain(s) {
+        if is_domain_name(s) {
             if is_nameserver(s) {
                 return Ok(QueryType::Nameserver(s.to_owned()));
             } else {
@@ -193,6 +206,10 @@ fn is_ldh_domain(text: &str) -> bool {
     LDH_DOMAIN_RE.is_match(text)
 }
 
+fn is_domain_name(text: &str) -> bool {
+    text.contains('.') && text.is_unicode_domain_name()
+}
+
 fn is_nameserver(text: &str) -> bool {
     lazy_static! {
         static ref NS_RE: Regex =

icann-rdap-common/src/check/string.rs

@@ -31,7 +31,12 @@ impl<T: ToString> StringCheck for T {
 
     fn is_unicode_domain_name(&self) -> bool {
         let s = self.to_string();
-        s == "." || !s.is_whitespace_or_empty()
+        s == "."
+            || (!s.is_empty()
+                && s.split_terminator('.').all(|s| {
+                    s.chars()
+                        .all(|c| c == '-' || (!c.is_ascii_punctuation() && !c.is_whitespace()))
+                }))
     }
 }
 
@@ -202,6 +207,8 @@ mod tests {
     #[case(".", true)]
     #[case("foo.bar", true)]
     #[case("foo.bar.", true)]
+    #[case("fo_o.bar.", false)]
+    #[case("fo o.bar.", false)]
     fn GIVEN_string_WHEN_is_unicode_domain_name_THEN_correct_result(
         #[case] test_string: &str,
         #[case] expected: bool,