The banishment of Address (#1880)

Co-authored-by: Jeffrey Dallatezza <[email protected]>

crates/bench/benches/subscription.rs

@@ -103,7 +103,7 @@ fn eval(c: &mut Criterion) {
             let tx = raw.db.begin_tx();
             let query = compile_read_only_query(&raw.db, &AuthCtx::for_testing(), &tx, sql).unwrap();
             let query: ExecutionSet = query.into();
-            let ctx = &ExecutionContext::subscribe(raw.db.address());
+            let ctx = &ExecutionContext::subscribe(raw.db.database_identity());
             b.iter(|| {
                 drop(black_box(query.eval::<BsatnFormat>(
                     ctx,
@@ -134,7 +134,7 @@ fn eval(c: &mut Criterion) {
     );
     bench_eval(c, "full-join", &name);
 
-    let ctx_incr = &ExecutionContext::incremental_update(raw.db.address());
+    let ctx_incr = &ExecutionContext::incremental_update(raw.db.database_identity());
 
     // To profile this benchmark for 30s
     // samply record -r 10000000 cargo bench --bench=subscription --profile=profiling -- incr-select --exact --profile-time=30

crates/bindings/tests/snapshots/deps__spacetimedb_bindings_dependencies.snap

@@ -71,6 +71,7 @@ spacetimedb
 │   │   └── syn (*)
 │   ├── hex
 │   ├── itertools (*)
+│   ├── rand (*)
 │   ├── spacetimedb_bindings_macro (*)
 │   ├── spacetimedb_data_structures
 │   │   ├── ahash

crates/cli/src/api.rs

@@ -5,21 +5,28 @@ use serde_json::value::RawValue;
 use spacetimedb_lib::db::raw_def::v9::RawModuleDefV9;
 use spacetimedb_lib::de::serde::DeserializeWrapper;
 use spacetimedb_lib::sats::ProductType;
-use spacetimedb_lib::Address;
+use spacetimedb_lib::Identity;
 
 static APP_USER_AGENT: &str = concat!(env!("CARGO_PKG_NAME"), "/", env!("CARGO_PKG_VERSION"),);
 
 #[derive(Debug, Clone)]
 pub struct Connection {
     pub(crate) host: String,
-    pub(crate) address: Address,
+    pub(crate) database_identity: Identity,
     pub(crate) database: String,
     pub(crate) auth_header: Option<String>,
 }
 
 impl Connection {
     pub fn db_uri(&self, endpoint: &str) -> String {
-        [&self.host, "/database/", endpoint, "/", &self.address.to_hex()].concat()
+        [
+            &self.host,
+            "/database/",
+            endpoint,
+            "/",
+            &self.database_identity.to_hex(),
+        ]
+        .concat()
     }
 }
 

crates/cli/src/subcommands/call.rs

@@ -2,14 +2,15 @@ use crate::common_args;
 use crate::config::Config;
 use crate::edit_distance::{edit_distance, find_best_match_for_name};
 use crate::util;
-use crate::util::{add_auth_header_opt, database_address, get_auth_header_only};
+use crate::util::{add_auth_header_opt, database_identity, get_auth_header_only};
 use anyhow::{bail, Context, Error};
 use clap::{Arg, ArgMatches};
 use itertools::Either;
 use serde_json::Value;
+use spacetimedb::Identity;
 use spacetimedb_lib::de::serde::deserialize_from;
 use spacetimedb_lib::sats::{AlgebraicType, AlgebraicTypeRef, Typespace};
-use spacetimedb_lib::{Address, ProductTypeElement};
+use spacetimedb_lib::ProductTypeElement;
 use std::fmt::Write;
 use std::iter;
 
@@ -19,7 +20,7 @@ pub fn cli() -> clap::Command {
         .arg(
             Arg::new("database")
                 .required(true)
-                .help("The database domain or address to use to invoke the call"),
+                .help("The database name or identity to use to invoke the call"),
         )
         .arg(
             Arg::new("reducer_name")
@@ -46,19 +47,19 @@ pub async fn exec(mut config: Config, args: &ArgMatches) -> Result<(), Error> {
     let identity = args.get_one::<String>("identity");
     let anon_identity = args.get_flag("anon_identity");
 
-    let address = database_address(&config, database, server).await?;
+    let database_identity = database_identity(&config, database, server).await?;
 
     let builder = reqwest::Client::new().post(format!(
         "{}/database/call/{}/{}",
         config.get_host_url(server)?,
-        address.clone(),
+        database_identity.clone(),
         reducer_name
     ));
     let auth_header = get_auth_header_only(&mut config, anon_identity, identity, server).await?;
     let builder = add_auth_header_opt(builder, &auth_header);
     let describe_reducer = util::describe_reducer(
         &mut config,
-        address,
+        database_identity,
         server.map(|x| x.to_string()),
         reducer_name.clone(),
         anon_identity,
@@ -90,11 +91,11 @@ pub async fn exec(mut config: Config, args: &ArgMatches) -> Result<(), Error> {
         let error = Err(e).context(format!("Response text: {}", response_text));
 
         let error_msg = if response_text.starts_with("no such reducer") {
-            no_such_reducer(config, &address, database, &auth_header, reducer_name, server).await
+            no_such_reducer(config, &database_identity, database, &auth_header, reducer_name, server).await
         } else if response_text.starts_with("invalid arguments") {
             invalid_arguments(
                 config,
-                &address,
+                &database_identity,
                 database,
                 &auth_header,
                 reducer_name,
@@ -115,16 +116,16 @@ pub async fn exec(mut config: Config, args: &ArgMatches) -> Result<(), Error> {
 /// Returns an error message for when `reducer` is called with wrong arguments.
 async fn invalid_arguments(
     config: Config,
-    addr: &Address,
+    identity: &Identity,
     db: &str,
     auth_header: &Option<String>,
     reducer: &str,
     text: &str,
     server: Option<&str>,
 ) -> String {
     let mut error = format!(
-        "Invalid arguments provided for reducer `{}` for database `{}` resolving to address `{}`.",
-        reducer, db, addr
+        "Invalid arguments provided for reducer `{}` for database `{}` resolving to identity `{}`.",
+        reducer, db, identity
     );
 
     if let Some((actual, expected)) = find_actual_expected(text).filter(|(a, e)| a != e) {
@@ -136,7 +137,7 @@ async fn invalid_arguments(
         .unwrap();
     }
 
-    if let Some(sig) = schema_json(config, addr, auth_header, true, server)
+    if let Some(sig) = schema_json(config, identity, auth_header, true, server)
         .await
         .and_then(|schema| reducer_signature(schema, reducer))
     {
@@ -198,18 +199,18 @@ fn reducer_signature(schema_json: Value, reducer_name: &str) -> Option<String> {
 /// Returns an error message for when `reducer` does not exist in `db`.
 async fn no_such_reducer(
     config: Config,
-    addr: &Address,
+    database_identity: &Identity,
     db: &str,
     auth_header: &Option<String>,
     reducer: &str,
     server: Option<&str>,
 ) -> String {
     let mut error = format!(
-        "No such reducer `{}` for database `{}` resolving to address `{}`.",
-        reducer, db, addr
+        "No such reducer `{}` for database `{}` resolving to identity `{}`.",
+        reducer, db, database_identity
     );
 
-    if let Some(schema) = schema_json(config, addr, auth_header, false, server).await {
+    if let Some(schema) = schema_json(config, database_identity, auth_header, false, server).await {
         add_reducer_ctx_to_err(&mut error, schema, reducer);
     }
 
@@ -255,20 +256,20 @@ fn add_reducer_ctx_to_err(error: &mut String, schema_json: Value, reducer_name:
     }
 }
 
-/// Fetch the schema as JSON for the database at `address`.
+/// Fetch the schema as JSON for the database at `identity`.
 ///
 /// The value of `expand` determines how detailed information to fetch.
 async fn schema_json(
     config: Config,
-    address: &Address,
+    identity: &Identity,
     auth_header: &Option<String>,
     expand: bool,
     server: Option<&str>,
 ) -> Option<Value> {
     let builder = reqwest::Client::new().get(format!(
         "{}/database/schema/{}",
         config.get_host_url(server).ok()?,
-        address
+        identity
     ));
     let builder = add_auth_header_opt(builder, auth_header);
 

crates/cli/src/subcommands/delete.rs

@@ -1,6 +1,6 @@
 use crate::common_args;
 use crate::config::Config;
-use crate::util::{add_auth_header_opt, database_address, get_auth_header_only};
+use crate::util::{add_auth_header_opt, database_identity, get_auth_header_only};
 use clap::{Arg, ArgMatches};
 
 pub fn cli() -> clap::Command {
@@ -9,7 +9,7 @@ pub fn cli() -> clap::Command {
         .arg(
             Arg::new("database")
                 .required(true)
-                .help("The domain or address of the database to delete"),
+                .help("The name or identity of the database to delete"),
         )
         .arg(
             common_args::identity()
@@ -28,9 +28,9 @@ pub async fn exec(mut config: Config, args: &ArgMatches) -> Result<(), anyhow::E
     let database = args.get_one::<String>("database").unwrap();
     let identity_or_name = args.get_one::<String>("identity");
 
-    let address = database_address(&config, database, server).await?;
+    let identity = database_identity(&config, database, server).await?;
 
-    let builder = reqwest::Client::new().post(format!("{}/database/delete/{}", config.get_host_url(server)?, address));
+    let builder = reqwest::Client::new().post(format!("{}/database/delete/{}", config.get_host_url(server)?, identity));
     let auth_header = get_auth_header_only(&mut config, false, identity_or_name, server).await?;
     let builder = add_auth_header_opt(builder, &auth_header);
     builder.send().await?.error_for_status()?;

crates/cli/src/subcommands/describe.rs

@@ -1,6 +1,6 @@
 use crate::common_args;
 use crate::config::Config;
-use crate::util::{add_auth_header_opt, database_address, get_auth_header_only};
+use crate::util::{add_auth_header_opt, database_identity, get_auth_header_only};
 use clap::{Arg, ArgMatches};
 
 pub fn cli() -> clap::Command {
@@ -9,7 +9,7 @@ pub fn cli() -> clap::Command {
         .arg(
             Arg::new("database")
                 .required(true)
-                .help("The domain or address of the database to describe"),
+                .help("The name or identity of the database to describe"),
         )
         .arg(
             Arg::new("entity_type")
@@ -46,14 +46,14 @@ pub async fn exec(mut config: Config, args: &ArgMatches) -> Result<(), anyhow::E
     let identity = args.get_one::<String>("identity");
     let anon_identity = args.get_flag("anon_identity");
 
-    let address = database_address(&config, database, server).await?;
+    let database_identity = database_identity(&config, database, server).await?;
 
     let builder = reqwest::Client::new().get(match entity_name {
-        None => format!("{}/database/schema/{}", config.get_host_url(server)?, address),
+        None => format!("{}/database/schema/{}", config.get_host_url(server)?, database_identity),
         Some(entity_name) => format!(
             "{}/database/schema/{}/{}/{}",
             config.get_host_url(server)?,
-            address,
+            database_identity,
             entity_type.unwrap(),
             entity_name
         ),

crates/cli/src/subcommands/dns.rs

@@ -40,25 +40,25 @@ fn get_subcommands() -> Vec<Command> {
             )
             .after_help("Run `spacetime dns register-tld --help` for more detailed information.\n"),
         Command::new("lookup")
-            .about("Resolves a domain to a database address")
+            .about("Resolves a domain to a database identity")
             .arg(Arg::new("domain").required(true).help("The name of the domain to lookup"))
             .arg(
                 common_args::server()
                     .help("The nickname, host name or URL of the server on which to look up the domain name"),
             )
             .after_help("Run `spacetime dns lookup --help` for more detailed information"),
         Command::new("reverse-lookup")
-            .about("Returns the domains for the provided database address")
-            .arg(Arg::new("address").required(true).help("The address you would like to find all of the known domains for"))
+            .about("Returns the domains for the provided database identity")
+            .arg(Arg::new("database-identity").required(true).help("The database identity you would like to find all of the known domains for"))
             .arg(
                 common_args::server()
-                    .help("The nickname, host name or URL of the server on which to look up the address"),
+                    .help("The nickname, host name or URL of the server on which to look up the database identity"),
             )
             .after_help("Run `spacetime dns reverse-lookup --help` for more detailed information.\n"),
         Command::new("set-name")
             .about("Sets the domain of the database")
             .arg(Arg::new("domain").required(true).help("The domain you would like to assign or create"))
-            .arg(Arg::new("address").required(true).help("The database address to assign to the domain"))
+            .arg(Arg::new("database-identity").required(true).help("The database identity to assign to the domain"))
             .arg(common_args::identity().long_help(
                 "The identity that owns the tld for this domain. If no identity is specified, the default identity is used.",
             ).help("The identity that owns the tld for this domain"))
@@ -107,8 +107,8 @@ pub async fn exec_dns_lookup(config: Config, args: &ArgMatches) -> Result<(), an
 
     let response = spacetime_dns(&config, domain, server).await?;
     match response {
-        DnsLookupResponse::Success { domain: _, address } => {
-            println!("{}", address);
+        DnsLookupResponse::Success { domain: _, identity } => {
+            println!("{}", identity);
         }
         DnsLookupResponse::Failure { domain } => {
             println!("No such database: {}", domain);
@@ -118,11 +118,14 @@ pub async fn exec_dns_lookup(config: Config, args: &ArgMatches) -> Result<(), an
 }
 
 pub async fn exec_reverse_dns(config: Config, args: &ArgMatches) -> Result<(), anyhow::Error> {
-    let addr = args.get_one::<String>("address").unwrap();
+    let database_identity = args.get_one::<String>("database-identity").unwrap();
     let server = args.get_one::<String>("server").map(|s| s.as_ref());
-    let response = spacetime_reverse_dns(&config, addr, server).await?;
+    let response = spacetime_reverse_dns(&config, database_identity, server).await?;
     if response.names.is_empty() {
-        Err(anyhow::anyhow!("Could not find a name for the address: {}", addr))
+        Err(anyhow::anyhow!(
+            "Could not find a name for the identity: {}",
+            database_identity
+        ))
     } else {
         for name in response.names {
             println!("{}", name);
@@ -133,7 +136,7 @@ pub async fn exec_reverse_dns(config: Config, args: &ArgMatches) -> Result<(), a
 
 pub async fn exec_set_name(mut config: Config, args: &ArgMatches) -> Result<(), anyhow::Error> {
     let domain = args.get_one::<String>("domain").unwrap();
-    let address = args.get_one::<String>("address").unwrap();
+    let database_identity = args.get_one::<String>("database-identity").unwrap();
     let identity = args.get_one::<String>("identity");
     let server = args.get_one::<String>("server").map(|s| s.as_ref());
     let auth_header = get_auth_header_only(&mut config, false, identity, server).await?;
@@ -142,7 +145,7 @@ pub async fn exec_set_name(mut config: Config, args: &ArgMatches) -> Result<(),
         format!("{}/database/set_name", config.get_host_url(server)?).as_str(),
         [
             ("domain", domain.clone()),
-            ("address", address.clone()),
+            ("database_identity", database_identity.clone()),
             ("register_tld", "true".to_string()),
         ],
     )?);
@@ -153,8 +156,11 @@ pub async fn exec_set_name(mut config: Config, args: &ArgMatches) -> Result<(),
     println!("{}", String::from_utf8_lossy(&bytes[..]));
     let result: InsertDomainResult = serde_json::from_slice(&bytes[..]).unwrap();
     match result {
-        InsertDomainResult::Success { domain, address } => {
-            println!("Domain set to {} for address {}.", domain, address);
+        InsertDomainResult::Success {
+            domain,
+            database_identity,
+        } => {
+            println!("Domain set to {} for identity {}.", domain, database_identity);
         }
         InsertDomainResult::TldNotRegistered { domain } => {
             return Err(anyhow::anyhow!(

crates/cli/src/subcommands/list.rs

@@ -4,7 +4,7 @@ use anyhow::Context;
 use clap::{ArgMatches, Command};
 use reqwest::StatusCode;
 use serde::Deserialize;
-use spacetimedb_lib::Address;
+use spacetimedb::Identity;
 use tabled::{
     settings::{object::Columns, Alignment, Modify, Style},
     Table, Tabled,
@@ -23,13 +23,13 @@ pub fn cli() -> Command {
 
 #[derive(Deserialize)]
 struct DatabasesResult {
-    pub addresses: Vec<AddressRow>,
+    pub identities: Vec<IdentityRow>,
 }
 
 #[derive(Tabled, Deserialize)]
 #[serde(transparent)]
-struct AddressRow {
-    pub db_address: Address,
+struct IdentityRow {
+    pub db_identity: Identity,
 }
 
 pub async fn exec(config: Config, args: &ArgMatches) -> Result<(), anyhow::Error> {
@@ -64,12 +64,12 @@ pub async fn exec(config: Config, args: &ArgMatches) -> Result<(), anyhow::Error
     let result: DatabasesResult = res.json().await?;
 
     let identity = identity_config.nick_or_identity();
-    if !result.addresses.is_empty() {
-        let mut table = Table::new(result.addresses);
+    if !result.identities.is_empty() {
+        let mut table = Table::new(result.identities);
         table
             .with(Style::psql())
             .with(Modify::new(Columns::first()).with(Alignment::left()));
-        println!("Associated database addresses for {}:\n", identity);
+        println!("Associated database identities for {}:\n", identity);
         println!("{}", table);
     } else {
         println!("No databases found for {}.", identity);