client-api: Resolve organization names via the tld, not the dns table (#4266)

As specified in the proposal.

Author: kim

crates/client-api/src/lib.rs

@@ -263,8 +263,9 @@ pub trait ControlStateReadAccess {
     async fn get_energy_balance(&self, identity: &Identity) -> anyhow::Result<Option<EnergyBalance>>;
 
     // DNS
-    async fn lookup_identity(&self, domain: &str) -> anyhow::Result<Option<Identity>>;
+    async fn lookup_database_identity(&self, domain: &str) -> anyhow::Result<Option<Identity>>;
     async fn reverse_lookup(&self, database_identity: &Identity) -> anyhow::Result<Vec<DomainName>>;
+    async fn lookup_namespace_owner(&self, name: &str) -> anyhow::Result<Option<Identity>>;
 }
 
 /// Write operations on the SpacetimeDB control plane.
@@ -355,22 +356,26 @@ impl<T: ControlStateReadAccess + Send + Sync + Sync + ?Sized> ControlStateReadAc
         (**self).get_replicas().await
     }
 
+    async fn get_leader_replica_by_database(&self, database_id: u64) -> Option<Replica> {
+        (**self).get_leader_replica_by_database(database_id).await
+    }
+
     // Energy
     async fn get_energy_balance(&self, identity: &Identity) -> anyhow::Result<Option<EnergyBalance>> {
         (**self).get_energy_balance(identity).await
     }
 
     // DNS
-    async fn lookup_identity(&self, domain: &str) -> anyhow::Result<Option<Identity>> {
-        (**self).lookup_identity(domain).await
+    async fn lookup_database_identity(&self, domain: &str) -> anyhow::Result<Option<Identity>> {
+        (**self).lookup_database_identity(domain).await
     }
 
     async fn reverse_lookup(&self, database_identity: &Identity) -> anyhow::Result<Vec<DomainName>> {
         (**self).reverse_lookup(database_identity).await
     }
 
-    async fn get_leader_replica_by_database(&self, database_id: u64) -> Option<Replica> {
-        (**self).get_leader_replica_by_database(database_id).await
+    async fn lookup_namespace_owner(&self, name: &str) -> anyhow::Result<Option<Identity>> {
+        (**self).lookup_namespace_owner(name).await
     }
 }
 

crates/client-api/src/routes/database.rs

@@ -715,7 +715,7 @@ pub async fn publish<S: NodeDelegate + ControlStateDelegate + Authorization>(
     };
     let maybe_org_identity = match organization.as_ref() {
         None => None,
-        Some(org) => org.resolve(&ctx).await.map(Some)?,
+        Some(org) => org.resolve_namespace_owner(&ctx).await.map(Some)?,
     };
 
     // Check that the replication factor looks somewhat sane.
@@ -1093,7 +1093,7 @@ pub async fn set_names<S: ControlStateDelegate + Authorization>(
         })?;
 
     for name in &validated_names {
-        if ctx.lookup_identity(name.as_str()).await.unwrap().is_some() {
+        if ctx.lookup_database_identity(name.as_str()).await.unwrap().is_some() {
             return Ok((
                 StatusCode::BAD_REQUEST,
                 axum::Json(name::SetDomainsResult::OtherError(format!(

crates/client-api/src/util.rs

@@ -100,7 +100,7 @@ impl NameOrIdentity {
     ) -> anyhow::Result<Result<Identity, &DatabaseName>> {
         Ok(match self {
             Self::Identity(identity) => Ok(Identity::from(*identity)),
-            Self::Name(name) => ctx.lookup_identity(name.as_ref()).await?.ok_or(name),
+            Self::Name(name) => ctx.lookup_database_identity(name.as_ref()).await?.ok_or(name),
         })
     }
 
@@ -111,7 +111,31 @@ impl NameOrIdentity {
         self.try_resolve(ctx)
             .await
             .map_err(log_and_500)?
-            .map_err(|name| (StatusCode::NOT_FOUND, format!("Could not resolve database `{name}`")).into())
+            .map_err(|name| (StatusCode::NOT_FOUND, format!("`{name}` not found")).into())
+    }
+
+    /// If `self` is a [`NameOrIdentity::Name`], looks up the name in the
+    /// namespace registry (also known as "top level domain") and returns the
+    /// owner identity if found.
+    ///
+    /// If the name is not found, returns a 404 (Not Found) error response.
+    ///
+    /// If `self` is a [`NameOrIdentity::Identity`], returns the identity.
+    //
+    // NOTE: Namespace (TLD) owner identities are also used as organization
+    // identities.
+    pub async fn resolve_namespace_owner(
+        &self,
+        ctx: &(impl ControlStateReadAccess + ?Sized),
+    ) -> axum::response::Result<Identity> {
+        match self {
+            Self::Identity(identity) => Ok(Identity::from(*identity)),
+            Self::Name(name) => ctx
+                .lookup_namespace_owner(name.as_ref())
+                .await
+                .map_err(log_and_500)?
+                .ok_or_else(|| (StatusCode::NOT_FOUND, format!("`{name}` not found")).into()),
+        }
     }
 }
 

crates/standalone/src/lib.rs

@@ -23,7 +23,9 @@ use spacetimedb::worker_metrics::WORKER_METRICS;
 use spacetimedb_client_api::auth::{self, LOCALHOST};
 use spacetimedb_client_api::routes::subscribe::{HasWebSocketOptions, WebSocketOptions};
 use spacetimedb_client_api::{ControlStateReadAccess, DatabaseResetDef, Host, NodeDelegate};
-use spacetimedb_client_api_messages::name::{DomainName, InsertDomainResult, RegisterTldResult, SetDomainsResult, Tld};
+use spacetimedb_client_api_messages::name::{
+    DatabaseName, DomainName, InsertDomainResult, RegisterTldResult, SetDomainsResult, Tld,
+};
 use spacetimedb_datastore::db_metrics::data_size::DATA_SIZE_METRICS;
 use spacetimedb_datastore::db_metrics::DB_METRICS;
 use spacetimedb_datastore::traits::Program;
@@ -240,13 +242,18 @@ impl spacetimedb_client_api::ControlStateReadAccess for StandaloneEnv {
     }
 
     // DNS
-    async fn lookup_identity(&self, domain: &str) -> anyhow::Result<Option<Identity>> {
+    async fn lookup_database_identity(&self, domain: &str) -> anyhow::Result<Option<Identity>> {
         Ok(self.control_db.spacetime_dns(domain)?)
     }
 
     async fn reverse_lookup(&self, database_identity: &Identity) -> anyhow::Result<Vec<DomainName>> {
         Ok(self.control_db.spacetime_reverse_dns(database_identity)?)
     }
+
+    async fn lookup_namespace_owner(&self, name: &str) -> anyhow::Result<Option<Identity>> {
+        let name: DatabaseName = name.parse()?;
+        Ok(self.control_db.spacetime_lookup_tld(Tld::from(name))?)
+    }
 }
 
 #[async_trait]