Merge branch 'main' into perpetual/gateway-dev

src/api/auth/login.rs

@@ -26,7 +26,7 @@ impl Instance {
         let response = LimitedRequester::send_request(
             request_builder,
             LimitType::AuthRegister,
-            &mut self.limits,
+            self,
             &mut cloned_limits,
         )
         .await;

src/api/auth/register.rs

@@ -12,13 +12,15 @@ use crate::{
 };
 
 impl Instance {
-    /**
+    /// Registers a new user on the Spacebar server.
-    Registers a new user on the Spacebar server.
+    ///
-    # Arguments
+    /// # Arguments
-    * `register_schema` - The [`RegisterSchema`] that contains all the information that is needed to register a new user.
+    ///
-    # Errors
+    /// * `register_schema` - The [`RegisterSchema`] that contains all the information that is needed to register a new user.
-    * [`ChorusLibError`] - If the server does not respond.
+    ///
-     */
+    /// # Errors
+    ///
+    /// * [`ChorusLibError`] - If the server does not respond.
     pub async fn register_account(
         &mut self,
         register_schema: &RegisterSchema,
@@ -34,7 +36,7 @@ impl Instance {
         let response = LimitedRequester::send_request(
             request_builder,
             LimitType::AuthRegister,
-            &mut self.limits,
+            self,
             &mut cloned_limits,
         )
         .await;
@@ -59,7 +61,7 @@ impl Instance {
             return Err(ChorusLibError::InvalidFormBodyError { error_type, error });
         }
         let user_object = self.get_user(token.clone(), None).await.unwrap();
-        let settings = UserMeta::get_settings(&token, &self.urls.api, &mut self.limits)
+        let settings = UserMeta::get_settings(&token, &self.urls.api.clone(), self)
             .await
             .unwrap();
         let user = UserMeta::new(

src/api/common.rs

@@ -15,7 +15,7 @@ pub async fn handle_request(
     LimitedRequester::send_request(
         request,
         limit_type,
-        &mut user.belongs_to.borrow_mut().limits,
+        &mut user.belongs_to.borrow_mut(),
         &mut user.limits,
     )
     .await

src/api/guilds/guilds.rs

@@ -7,6 +7,7 @@ use crate::api::handle_request;
 use crate::api::handle_request_as_result;
 use crate::api::limits::Limits;
 use crate::errors::ChorusLibError;
+use crate::instance::Instance;
 use crate::instance::UserMeta;
 use crate::limit::LimitedRequester;
 use crate::types::{Channel, ChannelCreateSchema, Guild, GuildCreateSchema};
@@ -101,7 +102,7 @@ impl Guild {
             &self.id.to_string(),
             schema,
             &mut user.limits,
-            &mut belongs_to.limits,
+            &mut belongs_to,
         )
         .await
     }
@@ -161,7 +162,7 @@ impl Guild {
             guild_id,
             &user.token,
             &mut user.limits,
-            &mut belongs_to.limits,
+            &mut belongs_to,
         )
         .await
     }
@@ -173,7 +174,7 @@ impl Guild {
         guild_id: &str,
         token: &str,
         limits_user: &mut Limits,
-        limits_instance: &mut Limits,
+        instance: &mut Instance,
     ) -> Result<Guild, ChorusLibError> {
         let request = Client::new()
             .get(format!("{}/guilds/{}/", url_api, guild_id))
@@ -181,7 +182,7 @@ impl Guild {
         let response = match LimitedRequester::send_request(
             request,
             crate::api::limits::LimitType::Guild,
-            limits_instance,
+            instance,
             limits_user,
         )
         .await
@@ -221,7 +222,7 @@ impl Channel {
             guild_id,
             schema,
             &mut user.limits,
-            &mut belongs_to.limits,
+            &mut belongs_to,
         )
         .await
     }
@@ -232,7 +233,7 @@ impl Channel {
         guild_id: &str,
         schema: ChannelCreateSchema,
         limits_user: &mut Limits,
-        limits_instance: &mut Limits,
+        instance: &mut Instance,
     ) -> Result<Channel, ChorusLibError> {
         let request = Client::new()
             .post(format!("{}/guilds/{}/channels/", url_api, guild_id))
@@ -241,7 +242,7 @@ impl Channel {
         let result = match LimitedRequester::send_request(
             request,
             crate::api::limits::LimitType::Guild,
-            limits_instance,
+            instance,
             limits_user,
         )
         .await

src/api/policies/instance/instance.rs

@@ -6,11 +6,9 @@ use crate::instance::Instance;
 use crate::types::GeneralConfiguration;
 
 impl Instance {
-    /**
+    /// Gets the instance policies schema.
-    Gets the instance policies schema.
+    /// # Errors
-    # Errors
+    /// [`ChorusLibError`] - If the request fails.
-    [`ChorusLibError`] - If the request fails.
-     */
     pub async fn general_configuration_schema(
         &self,
     ) -> Result<GeneralConfiguration, ChorusLibError> {

src/api/users/users.rs

@@ -10,16 +10,18 @@ use crate::{
 };
 
 impl UserMeta {
-    /**
+    /// Get a user object by id, or get the current user.
-    Get a user object by id, or get the current user.
+    ///
-    # Arguments
+    /// # Arguments
-    * `token` - A valid access token for the API.
+    ///
-    * `url_api` - The URL to the API.
+    /// * `token` - A valid access token for the API.
-    * `id` - The id of the user that will be retrieved. If this is None, the current user will be retrieved.
+    /// * `url_api` - The URL to the API.
-    * `instance_limits` - The [`Limits`] of the instance.
+    /// * `id` - The id of the user that will be retrieved. If this is None, the current user will be retrieved.
-    # Errors
+    /// * `instance_limits` - The [`Limits`] of the instance.
-    * [`ChorusLibError`] - If the request fails.
+    ///
-     */
+    /// # Errors
+    ///
+    /// * [`ChorusLibError`] - If the request fails.
     pub async fn get(user: &mut UserMeta, id: Option<&String>) -> Result<User, ChorusLibError> {
         User::get(user, id).await
     }
@@ -27,9 +29,9 @@ impl UserMeta {
     pub async fn get_settings(
         token: &String,
         url_api: &String,
-        instance_limits: &mut Limits,
+        instance: &mut Instance,
     ) -> Result<UserSettings, ChorusLibError> {
-        User::get_settings(token, url_api, instance_limits).await
+        User::get_settings(token, url_api, instance).await
     }
 
     /// Modify the current user's `UserObject`.
@@ -89,7 +91,7 @@ impl User {
         User::_get(
             &user.token(),
             &format!("{}", belongs_to.urls.api),
-            &mut belongs_to.limits,
+            &mut belongs_to,
             id,
         )
         .await
@@ -98,7 +100,7 @@ impl User {
     async fn _get(
         token: &str,
         url_api: &str,
-        limits_instance: &mut Limits,
+        instance: &mut Instance,
         id: Option<&String>,
     ) -> Result<User, ChorusLibError> {
         let url = if id.is_none() {
@@ -107,11 +109,11 @@ impl User {
             format!("{}/users/{}", url_api, id.unwrap())
         };
         let request = reqwest::Client::new().get(url).bearer_auth(token);
-        let mut cloned_limits = limits_instance.clone();
+        let mut cloned_limits = instance.limits.clone();
         match LimitedRequester::send_request(
             request,
             crate::api::limits::LimitType::Ip,
-            limits_instance,
+            instance,
             &mut cloned_limits,
         )
         .await
@@ -127,16 +129,16 @@ impl User {
     pub async fn get_settings(
         token: &String,
         url_api: &String,
-        instance_limits: &mut Limits,
+        instance: &mut Instance,
     ) -> Result<UserSettings, ChorusLibError> {
         let request: reqwest::RequestBuilder = Client::new()
             .get(format!("{}/users/@me/settings/", url_api))
             .bearer_auth(token);
-        let mut cloned_limits = instance_limits.clone();
+        let mut cloned_limits = instance.limits.clone();
         match LimitedRequester::send_request(
             request,
             crate::api::limits::LimitType::Ip,
-            instance_limits,
+            instance,
             &mut cloned_limits,
         )
         .await
@@ -163,6 +165,6 @@ impl Instance {
         token: String,
         id: Option<&String>,
     ) -> Result<User, ChorusLibError> {
-        User::_get(&token, &self.urls.api, &mut self.limits, id).await
+        User::_get(&token, &self.urls.api.clone(), self, id).await
     }
 }

src/instance.rs

@@ -2,6 +2,7 @@ use std::cell::RefCell;
 use std::fmt;
 use std::rc::Rc;
 
+use reqwest::Client;
 use serde::{Deserialize, Serialize};
 
 use crate::api::limits::Limits;
@@ -17,6 +18,7 @@ pub struct Instance {
     pub urls: UrlBundle,
     pub instance_info: GeneralConfiguration,
     pub limits: Limits,
+    pub client: Client,
 }
 
 impl Instance {
@@ -32,6 +34,7 @@ impl Instance {
             // Will be overwritten in the next step
             instance_info: GeneralConfiguration::default(),
             limits: Limits::check_limits(urls.api).await,
+            client: Client::new(),
         };
         instance.instance_info = match instance.general_configuration_schema().await {
             Ok(schema) => schema,

src/limit.rs

@@ -1,21 +1,50 @@
-use reqwest::{Client, RequestBuilder, Response};
+use reqwest::{RequestBuilder, Response};
 
 use crate::{
     api::limits::{Limit, LimitType, Limits, LimitsMutRef},
     errors::ChorusLibError,
+    instance::Instance,
 };
 
 #[derive(Debug)]
 pub struct LimitedRequester;
 
 impl LimitedRequester {
+    /// Checks if a request can be sent without hitting API rate limits and sends it, if true.
+    /// Will automatically update the rate limits of the LimitedRequester the request has been
+    /// sent with.
+    ///
+    /// # Arguments
+    ///
+    /// * `request`: A `RequestBuilder` that contains a request ready to be sent. Unfinished or
+    /// invalid requests will result in the method panicing.
+    /// * `limit_type`: Because this library does not yet implement a way to check for which rate
+    /// limit will be used when the request gets send, you will have to specify this manually using
+    /// a `LimitType` enum.
+    ///
+    /// # Returns
+    ///
+    /// * `Response`: The `Response` gotten from sending the request to the server. This will be
+    /// returned if the Request was built and send successfully. Is wrapped in an `Option`.
+    /// * `None`: `None` will be returned if the rate limit has been hit, and the request could
+    /// therefore not have been sent.
+    ///
+    /// # Errors
+    ///
+    /// This method will error if:
+    ///
+    /// * The request does not return a success status code (200-299)
+    /// * The supplied `RequestBuilder` contains invalid or incomplete information
+    /// * There has been an error with processing (unwrapping) the `Response`
+    /// * The call to `update_limits` yielded errors. Read the methods' Errors section for more
+    /// information.
     pub async fn send_request(
         request: RequestBuilder,
         limit_type: LimitType,
-        instance_rate_limits: &mut Limits,
+        instance: &mut Instance,
         user_rate_limits: &mut Limits,
     ) -> Result<Response, ChorusLibError> {
-        if LimitedRequester::can_send_request(limit_type, instance_rate_limits, user_rate_limits) {
+        if LimitedRequester::can_send_request(limit_type, &instance.limits, user_rate_limits) {
             let built_request = match request.build() {
                 Ok(request) => request,
                 Err(e) => {
@@ -25,7 +54,7 @@ impl LimitedRequester {
                     });
                 }
             };
-            let result = Client::new().execute(built_request).await;
+            let result = instance.client.execute(built_request).await;
             let response = match result {
                 Ok(is_response) => is_response,
                 Err(e) => {
@@ -37,7 +66,7 @@ impl LimitedRequester {
             LimitedRequester::update_limits(
                 &response,
                 limit_type,
-                instance_rate_limits,
+                &mut instance.limits,
                 user_rate_limits,
             );
             if !response.status().is_success() {
@@ -228,17 +257,17 @@ mod rate_limit {
             String::from("http://localhost:3001/cdn"),
         );
         let mut request: Option<Result<Response, ChorusLibError>> = None;
-        let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await;
+        let mut instance = Instance::new(urls.clone()).await.unwrap();
         let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await;
 
         for _ in 0..=50 {
             let request_path = urls.api.clone() + "/some/random/nonexisting/path";
-            let request_builder = Client::new().get(request_path);
+            let request_builder = instance.client.get(request_path);
             request = Some(
                 LimitedRequester::send_request(
                     request_builder,
                     LimitType::Channel,
-                    &mut instance_rate_limits,
+                    &mut instance,
                     &mut user_rate_limits,
                 )
                 .await,
@@ -254,15 +283,15 @@ mod rate_limit {
             String::from("wss://localhost:3001/"),
             String::from("http://localhost:3001/cdn"),
         );
-        let mut instance_rate_limits = Limits::check_limits(urls.api.clone()).await;
+        let mut instance = Instance::new(urls.clone()).await.unwrap();
         let mut user_rate_limits = Limits::check_limits(urls.api.clone()).await;
         let _requester = LimitedRequester;
         let request_path = urls.api.clone() + "/policies/instance/limits";
-        let request_builder = Client::new().get(request_path);
+        let request_builder = instance.client.get(request_path);
         let request = LimitedRequester::send_request(
             request_builder,
             LimitType::Channel,
-            &mut instance_rate_limits,
+            &mut instance,
             &mut user_rate_limits,
         )
         .await;