merge main into dev (#464)

## Fixes

- Fix gateway heartbeat on WASM: #460

## Changes

- Update `GuildDefaults` to use new enums
- Make new enums derive `sqlx::Type`
- Feature lock UpdateMessage implementations

## Package changes

- Bump package version, especially reqwest from 0.11.22->0.11.23 -
removes need for custom git branch in Cargo.toml

Cargo.lock

@@ -199,7 +199,7 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "chorus"
-version = "0.13.0"
+version = "0.14.0"
 dependencies = [
  "async-trait",
  "base64 0.21.7",
@@ -221,7 +221,6 @@ dependencies = [
  "reqwest",
  "rustls",
  "rustls-native-certs",
- "safina-timer",
  "serde",
  "serde-aux",
  "serde_json",
@@ -235,6 +234,7 @@ dependencies = [
  "wasm-bindgen",
  "wasm-bindgen-futures",
  "wasm-bindgen-test",
+ "wasmtimer",
  "ws_stream_wasm",
 ]
 
@@ -1688,15 +1688,6 @@ version = "1.0.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f98d2aa92eebf49b69786be48e4477826b256916e84a57ff2a4f21923b48eb4c"
 
-[[package]]
-name = "safina-timer"
-version = "0.1.11"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1081a264d1a3e81b75c4bcd5696094fb6ce470c2ded14cbd47bcb5229079b9df"
-dependencies = [
- "once_cell",
-]
-
 [[package]]
 name = "schannel"
 version = "0.1.23"
@@ -2688,6 +2679,20 @@ dependencies = [
  "syn 2.0.48",
 ]
 
+[[package]]
+name = "wasmtimer"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5f656cd8858a5164932d8a90f936700860976ec21eb00e0fe2aa8cab13f6b4cf"
+dependencies = [
+ "futures",
+ "js-sys",
+ "parking_lot",
+ "pin-utils",
+ "slab",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "web-sys"
 version = "0.3.66"

Cargo.toml

@@ -1,7 +1,7 @@
 [package]
 name = "chorus"
 description = "A library for interacting with multiple Spacebar-compatible Instances at once."
-version = "0.13.0"
+version = "0.14.0"
 license = "AGPL-3.0"
 edition = "2021"
 repository = "https://github.com/polyphony-chat/chorus"
@@ -52,7 +52,6 @@ sqlx = { version = "0.7.3", features = [
     "runtime-tokio-native-tls",
     "any",
 ], optional = true }
-safina-timer = "0.1.11"
 rand = "0.8.5"
 
 [target.'cfg(not(target_arch = "wasm32"))'.dependencies]
@@ -69,6 +68,7 @@ hostname = "0.3.1"
 getrandom = { version = "0.2.12", features = ["js"] }
 ws_stream_wasm = "0.7.4"
 wasm-bindgen-futures = "0.4.39"
+wasmtimer = "0.2.0"
 
 [dev-dependencies]
 lazy_static = "1.4.0"

README.md

@@ -44,7 +44,7 @@ To get started with Chorus, import it into your project by adding the following
 
 ```toml
 [dependencies]
-chorus = "0.13.0"
+chorus = "0.14.0"
 ```
 
 ### Establishing a Connection

examples/gateway_observers.rs

@@ -8,6 +8,11 @@ use chorus::{
 use std::{sync::Arc, time::Duration};
 use tokio::{self};
 
+#[cfg(not(target_arch = "wasm32"))]
+use tokio::time::sleep;
+#[cfg(target_arch = "wasm32")]
+use wasmtimer::tokio::sleep;
+
 // This example creates a simple gateway connection and a basic observer struct
 
 // Due to certain limitations all observers must impl debug
@@ -54,10 +59,9 @@ async fn main() {
     let mut identify = GatewayIdentifyPayload::common();
     identify.token = token;
     gateway.send_identify(identify).await;
-    safina_timer::start_timer_thread();
 
     // Do something on the main thread so we don't quit
     loop {
-        safina_timer::sleep_for(Duration::MAX).await
+        sleep(Duration::from_secs(3600)).await;
     }
 }

examples/gateway_simple.rs

@@ -3,6 +3,11 @@ use std::time::Duration;
 use chorus::gateway::Gateway;
 use chorus::{self, types::GatewayIdentifyPayload};
 
+#[cfg(not(target_arch = "wasm32"))]
+use tokio::time::sleep;
+#[cfg(target_arch = "wasm32")]
+use wasmtimer::tokio::sleep;
+
 /// This example creates a simple gateway connection and a session with an Identify event
 #[tokio::main(flavor = "current_thread")]
 async fn main() {
@@ -10,7 +15,7 @@ async fn main() {
     let websocket_url_spacebar = "wss://gateway.old.server.spacebar.chat/".to_string();
 
     // Initiate the gateway connection, starting a listener in one thread and a heartbeat handler in another
-    let _ = Gateway::spawn(websocket_url_spacebar).await.unwrap();
+    let gateway = Gateway::spawn(websocket_url_spacebar).await.unwrap();
 
     // At this point, we are connected to the server and are sending heartbeats, however we still haven't authenticated
 
@@ -26,10 +31,10 @@ async fn main() {
     identify.token = token;
 
     // Send off the event
-    safina_timer::start_timer_thread();
+    gateway.send_identify(identify).await; 
     
     // Do something on the main thread so we don't quit
     loop {
-        safina_timer::sleep_for(Duration::MAX).await
+        sleep(Duration::from_secs(3600)).await;
     }
 }

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(
+    let instance = Instance::new("https://example.com/")
-        "https://example.com/api".to_string(),
-        "wss://example.com/".to_string(),
-        "https://example.com/cdn".to_string(),
-    );
-    let instance = Instance::new(bundle)
         .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(
+    let mut instance = Instance::new("https://example.com/")
-        "https://example.com/api".to_string(),
-        "wss://example.com/".to_string(),
-        "https://example.com/cdn".to_string(),
-    );
-    let mut instance = Instance::new(bundle)
         .await
         .expect("Failed to connect to the Spacebar server");
     // Assume, you already have an account created on this instance. Registering an account works

src/gateway/heartbeat.rs

@@ -1,9 +1,20 @@
 use futures_util::SinkExt;
 use log::*;
-use std::time::{self, Duration, Instant};
+
+#[cfg(not(target_arch = "wasm32"))]
+use tokio::time::Instant;
+#[cfg(target_arch = "wasm32")]
+use wasmtimer::std::Instant;
+
+#[cfg(not(target_arch = "wasm32"))]
+use tokio::time::sleep_until;
+#[cfg(target_arch = "wasm32")]
+use wasmtimer::tokio::sleep_until;
+
+use std::time::Duration;
+
 use tokio::sync::mpsc::{Receiver, Sender};
 
-use safina_timer::sleep_until;
 #[cfg(not(target_arch = "wasm32"))]
 use tokio::task;
 
@@ -57,12 +68,10 @@ impl HeartbeatHandler {
         mut receive: Receiver<HeartbeatThreadCommunication>,
         mut kill_receive: tokio::sync::broadcast::Receiver<()>,
     ) {
-        let mut last_heartbeat_timestamp: Instant = time::Instant::now();
+        let mut last_heartbeat_timestamp: Instant = Instant::now();
         let mut last_heartbeat_acknowledged = true;
         let mut last_seq_number: Option<u64> = None;
          
-        safina_timer::start_timer_thread();
-
         loop {
             if kill_receive.try_recv().is_ok() {
                 trace!("GW: Closing heartbeat task");
@@ -123,7 +132,7 @@ impl HeartbeatHandler {
                     break;
                 }
 
-                last_heartbeat_timestamp = time::Instant::now();
+                last_heartbeat_timestamp = Instant::now();
                 last_heartbeat_acknowledged = false;
             }
         }

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(
+    let instance = Instance::new("http://localhost:3001/api").await.unwrap();
-        "http://localhost:3001/api".to_string(),
-        "ws://localhost:3001".to_string(),
-        "http://localhost:3001".to_string(),
-    );
-    let instance = Instance::new(urls.clone()).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,