Refactor instance creation

examples/instance.rs

@@ -1,14 +1,8 @@
 use chorus::instance::Instance;
-use chorus::UrlBundle;
 
 #[tokio::main(flavor = "current_thread")]
 async fn main() {
-    let bundle = UrlBundle::new(
-        "https://example.com/api".to_string(),
-        "wss://example.com/".to_string(),
-        "https://example.com/cdn".to_string(),
-    );
-    let instance = Instance::new(bundle)
+    let instance = Instance::new("https://example.com/")
         .await
         .expect("Failed to connect to the Spacebar server");
     dbg!(instance.instance_info);

examples/login.rs

@@ -1,15 +1,9 @@
 use chorus::instance::Instance;
 use chorus::types::LoginSchema;
-use chorus::UrlBundle;
 
 #[tokio::main(flavor = "current_thread")]
 async fn main() {
-    let bundle = UrlBundle::new(
-        "https://example.com/api".to_string(),
-        "wss://example.com/".to_string(),
-        "https://example.com/cdn".to_string(),
-    );
-    let mut instance = Instance::new(bundle)
+    let mut instance = Instance::new("https://example.com/")
         .await
         .expect("Failed to connect to the Spacebar server");
     // Assume, you already have an account created on this instance. Registering an account works

src/instance.rs

@@ -73,7 +73,7 @@ impl PartialEq for LimitsInformation {
 
 impl Instance {
     /// Creates a new [`Instance`] from the [relevant instance urls](UrlBundle). To create an Instance from one singular url, use [`Instance::from_root_url()`].
-    pub async fn new(urls: UrlBundle) -> ChorusResult<Instance> {
+    async fn from_url_bundle(urls: UrlBundle) -> ChorusResult<Instance> {
         let is_limited: Option<LimitsConfiguration> = Instance::is_limited(&urls.api).await?;
         let limit_information;
 
@@ -114,9 +114,9 @@ impl Instance {
     /// Shorthand for `Instance::new(UrlBundle::from_root_domain(root_domain).await?)`.
     ///
     /// If `limited` is `true`, then Chorus will track and enforce rate limits for this instance.
-    pub async fn from_root_url(root_url: &str) -> ChorusResult<Instance> {
+    pub async fn new(root_url: &str) -> ChorusResult<Instance> {
         let urls = UrlBundle::from_root_url(root_url).await?;
-        Instance::new(urls).await
+        Instance::from_url_bundle(urls).await
     }
 
     pub async fn is_limited(api_url: &str) -> ChorusResult<Option<LimitsConfiguration>> {

src/lib.rs

@@ -137,6 +137,12 @@ pub mod voice;
 /// # Notes
 /// All the urls can be found on the /api/policies/instance/domains endpoint of a spacebar server
 pub struct UrlBundle {
+    /// The root url of an Instance. Usually, this would be the url where `.well-known/spacebar` can
+    /// be located under. If the instance you are connecting to for some reason does not have a
+    /// `.well-known` set up (for example, if it is a local/testing instance), you can use the api
+    /// url as a substitute.
+    /// Ex: `https://spacebar.chat`
+    pub root: String,
     /// The api's url.
     /// Ex: `https://old.server.spacebar.chat/api`
     pub api: String,
@@ -151,8 +157,9 @@ pub struct UrlBundle {
 
 impl UrlBundle {
     /// Creates a new UrlBundle from the relevant urls.
-    pub fn new(api: String, wss: String, cdn: String) -> Self {
+    pub fn new(root: String, api: String, wss: String, cdn: String) -> Self {
         Self {
+            root: UrlBundle::parse_url(root),
             api: UrlBundle::parse_url(api),
             wss: UrlBundle::parse_url(wss),
             cdn: UrlBundle::parse_url(cdn),
@@ -237,7 +244,12 @@ impl UrlBundle {
             .json::<types::types::domains_configuration::Domains>()
             .await
         {
-            Ok(UrlBundle::new(body.api_endpoint, body.gateway, body.cdn))
+            Ok(UrlBundle::new(
+                url.to_string(),
+                body.api_endpoint,
+                body.gateway,
+                body.cdn,
+            ))
         } else {
             Err(ChorusError::RequestFailed {
                 url: url.to_string(),

tests/common/mod.rs

@@ -52,12 +52,7 @@ impl TestBundle {
 
 // Set up a test by creating an Instance and a User. Reduces Test boilerplate.
 pub(crate) async fn setup() -> TestBundle {
-    let urls = UrlBundle::new(
-        "http://localhost:3001/api".to_string(),
-        "ws://localhost:3001".to_string(),
-        "http://localhost:3001".to_string(),
-    );
-    let instance = Instance::new(urls.clone()).await.unwrap();
+    let instance = Instance::new("http://localhost:3001/api").await.unwrap();
     // Requires the existance of the below user.
     let reg = RegisterSchema {
         username: "integrationtestuser".into(),
@@ -114,6 +109,12 @@ pub(crate) async fn setup() -> TestBundle {
         .await
         .unwrap();
 
+    let urls = UrlBundle::new(
+        "http://localhost:3001/api".to_string(),
+        "http://localhost:3001/api".to_string(),
+        "ws://localhost:3001".to_string(),
+        "http://localhost:3001".to_string(),
+    );
     TestBundle {
         urls,
         user,