More compact representation of DomainName

clockworklabs · Aug 9, 2023 · 252cf2e · 252cf2e
1 parent 537b3c7
commit 252cf2e
Show file tree

Hide file tree

Showing 5 changed files with 292 additions and 215 deletions.
diff --git a/crates/client-api/src/routes/database.rs b/crates/client-api/src/routes/database.rs
@@ -626,7 +626,7 @@ pub async fn register_tld(
     // so, unless you are the owner, this will fail, hence not using get_or_create
     let auth = auth_or_bad_request(auth)?;
 
-    let tld = tld.parse::<DomainName>().map_err(DomainParsingRejection)?.into_tld();
+    let tld = tld.parse::<DomainName>().map_err(DomainParsingRejection)?.into();
     let result = ctx
         .control_db()
         .spacetime_register_tld(tld, auth.identity)

diff --git a/crates/core/src/control_db.rs b/crates/core/src/control_db.rs
@@ -6,7 +6,7 @@ use crate::identity::Identity;
 use crate::messages::control_db::{Database, DatabaseInstance, EnergyBalance, IdentityEmail, Node};
 use crate::stdb_path;
 
-use spacetimedb_lib::name::{DomainName, DomainParsingError, InsertDomainResult, RegisterTldResult, Tld};
+use spacetimedb_lib::name::{DomainName, DomainParsingError, InsertDomainResult, RegisterTldResult, Tld, TldRef};
 use spacetimedb_lib::recovery::RecoveryCode;
 use spacetimedb_sats::bsatn;
 
@@ -124,7 +124,7 @@ impl ControlDb {
                 if try_register_tld {
                     // Let's try to automatically register this TLD for the identity
                     let result = self
-                        .spacetime_register_tld(domain.tld().clone(), owner_identity)
+                        .spacetime_register_tld(domain.tld().to_owned(), owner_identity)
                         .await?;
                     if let RegisterTldResult::Success { .. } = result {
                         // This identity now owns this TLD
@@ -167,7 +167,8 @@ impl ControlDb {
     /// * `owner_identity` - The identity that should own this domain name.
     pub async fn spacetime_register_tld(&self, tld: Tld, owner_identity: Identity) -> Result<RegisterTldResult> {
         let tree = self.db.open_tree("top_level_domains")?;
-        let current_owner = tree.get(tld.as_lowercase().as_bytes())?;
+        let key = tld.to_lowercase();
+        let current_owner = tree.get(&key)?;
         match current_owner {
             Some(owner) => {
                 if Identity::from_slice(&owner[..]) == owner_identity {
@@ -177,7 +178,7 @@ impl ControlDb {
                 }
             }
             None => {
-                tree.insert(tld.as_lowercase().as_bytes(), owner_identity.as_bytes())?;
+                tree.insert(key, owner_identity.as_bytes())?;
                 Ok(RegisterTldResult::Success { domain: tld })
             }
         }
@@ -226,9 +227,9 @@ impl ControlDb {
     ///
     /// # Arguments
     ///  * `domain` - The domain to lookup
-    pub async fn spacetime_lookup_tld(&self, domain: &Tld) -> Result<Option<Identity>> {
+    pub async fn spacetime_lookup_tld(&self, domain: impl AsRef<TldRef>) -> Result<Option<Identity>> {
         let tree = self.db.open_tree("top_level_domains")?;
-        match tree.get(domain.as_lowercase().as_bytes())? {
+        match tree.get(domain.as_ref().to_lowercase().as_bytes())? {
             Some(owner) => Ok(Some(Identity::from_slice(&owner[..]))),
             None => Ok(None),
         }

diff --git a/crates/core/src/control_db/tests.rs b/crates/core/src/control_db/tests.rs
@@ -19,19 +19,19 @@ async fn test_register_tld() -> anyhow::Result<()> {
     })
     .await??;
 
-    cdb.spacetime_register_tld(domain.tld().clone(), *ALICE).await?;
+    cdb.spacetime_register_tld(domain.tld().to_owned(), *ALICE).await?;
     let owner = cdb.spacetime_lookup_tld(domain.tld()).await?;
     assert_eq!(owner, Some(*ALICE));
 
-    let unauthorized = cdb.spacetime_register_tld(domain.tld().clone(), *BOB).await?;
+    let unauthorized = cdb.spacetime_register_tld(domain.tld().to_owned(), *BOB).await?;
     assert!(matches!(unauthorized, RegisterTldResult::Unauthorized { .. }));
-    let already_registered = cdb.spacetime_register_tld(domain.tld().clone(), *ALICE).await?;
+    let already_registered = cdb.spacetime_register_tld(domain.tld().to_owned(), *ALICE).await?;
     assert!(matches!(
         already_registered,
         RegisterTldResult::AlreadyRegistered { .. }
     ));
-    let (mixed, _) = DomainName::from_str("amAZe")?.into_parts();
-    let already_registered = cdb.spacetime_register_tld(mixed, *ALICE).await?;
+    let domain = DomainName::from_str("amAZe")?;
+    let already_registered = cdb.spacetime_register_tld(domain.tld().to_owned(), *ALICE).await?;
     assert!(matches!(
         already_registered,
         RegisterTldResult::AlreadyRegistered { .. }
@@ -59,7 +59,7 @@ async fn test_domain() -> anyhow::Result<()> {
 
     // Check Alice owns TLD
     let unauthorized = cdb
-        .spacetime_insert_domain(&addr, domain.tld().clone().into(), *BOB, true)
+        .spacetime_insert_domain(&addr, domain.tld().to_owned().into(), *BOB, true)
         .await?;
     assert!(matches!(unauthorized, InsertDomainResult::PermissionDenied { .. }));