Fix failing build w/o client and move ratelimits (#426)

* Fix failing build without client feature

* Feature lock Updateable and Composite

src/api/auth/login.rs

@@ -3,12 +3,11 @@ use std::sync::{Arc, RwLock};
 use reqwest::Client;
 use serde_json::to_string;
 
-use crate::api::LimitType;
 use crate::errors::ChorusResult;
 use crate::gateway::Gateway;
 use crate::instance::{ChorusUser, Instance};
 use crate::ratelimiter::ChorusRequest;
-use crate::types::{GatewayIdentifyPayload, LoginResult, LoginSchema};
+use crate::types::{GatewayIdentifyPayload, LimitType, LoginResult, LoginSchema};
 
 impl Instance {
     /// Logs into an existing account on the spacebar server.

src/api/auth/register.rs

@@ -6,10 +6,10 @@ use serde_json::to_string;
 use crate::gateway::Gateway;
 use crate::types::GatewayIdentifyPayload;
 use crate::{
-    api::policies::instance::LimitType,
     errors::ChorusResult,
     instance::{ChorusUser, Instance, Token},
     ratelimiter::ChorusRequest,
+    types::LimitType,
     types::RegisterSchema,
 };
 

src/api/channels/channels.rs

@@ -3,11 +3,12 @@ use serde_json::to_string;
 
 use crate::types::{AddChannelRecipientSchema, ModifyChannelPositionsSchema};
 use crate::{
-    api::LimitType,
     errors::{ChorusError, ChorusResult},
     instance::ChorusUser,
     ratelimiter::ChorusRequest,
-    types::{Channel, ChannelModifySchema, GetChannelMessagesSchema, Message, Snowflake},
+    types::{
+        Channel, ChannelModifySchema, GetChannelMessagesSchema, LimitType, Message, Snowflake,
+    },
 };
 
 impl Channel {

src/api/channels/messages.rs

@@ -3,13 +3,12 @@ use http::HeaderMap;
 use reqwest::{multipart, Client};
 use serde_json::{from_value, to_string, Value};
 
-use crate::api::LimitType;
 use crate::errors::{ChorusError, ChorusResult};
 use crate::instance::ChorusUser;
 use crate::ratelimiter::ChorusRequest;
 use crate::types::{
-    Channel, CreateGreetMessage, Message, MessageAck, MessageModifySchema, MessageSearchEndpoint,
+    Channel, CreateGreetMessage, LimitType, Message, MessageAck, MessageModifySchema,
-    MessageSearchQuery, MessageSendSchema, Snowflake,
+    MessageSearchEndpoint, MessageSearchQuery, MessageSendSchema, Snowflake,
 };
 
 impl Message {

src/api/channels/permissions.rs

@@ -2,11 +2,10 @@ use reqwest::Client;
 use serde_json::to_string;
 
 use crate::{
-    api::LimitType,
     errors::{ChorusError, ChorusResult},
     instance::ChorusUser,
     ratelimiter::ChorusRequest,
-    types::{self, PermissionOverwrite, Snowflake},
+    types::{self, LimitType, PermissionOverwrite, Snowflake},
 };
 
 impl types::Channel {

src/api/channels/reactions.rs

@@ -1,9 +1,8 @@
 use crate::{
-    api::LimitType,
     errors::ChorusResult,
     instance::ChorusUser,
     ratelimiter::ChorusRequest,
-    types::{self, PublicUser, Snowflake},
+    types::{self, LimitType, PublicUser, Snowflake},
 };
 
 /// Useful metadata for working with [`types::Reaction`], bundled together nicely.

src/api/guilds/guilds.rs

@@ -2,14 +2,13 @@ use reqwest::Client;
 use serde_json::from_str;
 use serde_json::to_string;
 
-use crate::api::LimitType;
 use crate::errors::ChorusError;
 use crate::errors::ChorusResult;
 use crate::instance::ChorusUser;
 use crate::ratelimiter::ChorusRequest;
 use crate::types::{
     Channel, ChannelCreateSchema, Guild, GuildBanCreateSchema, GuildBansQuery, GuildCreateSchema,
-    GuildMember, GuildMemberSearchSchema, GuildModifySchema, GuildPreview,
+    GuildMember, GuildMemberSearchSchema, GuildModifySchema, GuildPreview, LimitType,
     ModifyGuildMemberProfileSchema, ModifyGuildMemberSchema, UserProfileMetadata,
 };
 use crate::types::{GuildBan, Snowflake};

src/api/guilds/member.rs

@@ -1,11 +1,10 @@
 use reqwest::Client;
 
 use crate::{
-    api::LimitType,
     errors::ChorusResult,
     instance::ChorusUser,
     ratelimiter::ChorusRequest,
-    types::{self, GuildMember, Snowflake},
+    types::{self, GuildMember, LimitType, Snowflake},
 };
 
 impl types::GuildMember {

src/api/guilds/roles.rs

@@ -2,11 +2,12 @@ use reqwest::Client;
 use serde_json::to_string;
 
 use crate::{
-    api::LimitType,
     errors::{ChorusError, ChorusResult},
     instance::ChorusUser,
     ratelimiter::ChorusRequest,
-    types::{self, RoleCreateModifySchema, RoleObject, RolePositionUpdateSchema, Snowflake},
+    types::{
+        self, LimitType, RoleCreateModifySchema, RoleObject, RolePositionUpdateSchema, Snowflake,
+    },
 };
 
 impl types::RoleObject {

src/api/invites/mod.rs

@@ -4,7 +4,7 @@ use serde_json::to_string;
 use crate::errors::ChorusResult;
 use crate::instance::ChorusUser;
 use crate::ratelimiter::ChorusRequest;
-use crate::types::{CreateChannelInviteSchema, GuildInvite, Invite, Snowflake};
+use crate::types::{CreateChannelInviteSchema, GuildInvite, Invite, LimitType, Snowflake};
 
 impl ChorusUser {
     /// Accepts an invite to a guild, group DM, or DM.
@@ -26,7 +26,7 @@ impl ChorusUser {
                     invite_code
                 ))
                 .header("Authorization", self.token()),
-            limit_type: super::LimitType::Global,
+            limit_type: LimitType::Global,
         };
         if session_id.is_some() {
             request.request = request
@@ -53,7 +53,7 @@ impl ChorusUser {
                 .body(to_string(&code).unwrap())
                 .header("Authorization", self.token())
                 .header("Content-Type", "application/json"),
-            limit_type: super::LimitType::Global,
+            limit_type: LimitType::Global,
         }
         .deserialize_response::<Invite>(self)
         .await
@@ -81,7 +81,7 @@ impl ChorusUser {
                 .header("Authorization", self.token())
                 .header("Content-Type", "application/json")
                 .body(to_string(&create_channel_invite_schema).unwrap()),
-            limit_type: super::LimitType::Channel(channel_id),
+            limit_type: LimitType::Channel(channel_id),
         }
         .deserialize_response::<GuildInvite>(self)
         .await

src/api/mod.rs

@@ -3,7 +3,6 @@ pub use channels::messages::*;
 pub use guilds::*;
 pub use invites::*;
 pub use policies::instance::instance::*;
-pub use policies::instance::ratelimits::*;
 pub use users::*;
 
 pub mod auth;

src/api/policies/instance/mod.rs

@@ -1,5 +1,3 @@
 pub use instance::*;
-pub use ratelimits::*;
 
 pub mod instance;
-pub mod ratelimits;

src/api/policies/mod.rs

@@ -1,3 +1 @@
-pub use instance::ratelimits::*;
-
 pub mod instance;

src/api/users/channels.rs

@@ -2,11 +2,10 @@ use reqwest::Client;
 use serde_json::to_string;
 
 use crate::{
-    api::LimitType,
     errors::ChorusResult,
     instance::ChorusUser,
     ratelimiter::ChorusRequest,
-    types::{Channel, PrivateChannelCreateSchema},
+    types::{Channel, LimitType, PrivateChannelCreateSchema},
 };
 
 impl ChorusUser {

src/api/users/guilds.rs

@@ -1,11 +1,10 @@
 use reqwest::Client;
 use serde_json::to_string;
 
-use crate::api::LimitType;
 use crate::errors::ChorusResult;
 use crate::instance::ChorusUser;
 use crate::ratelimiter::ChorusRequest;
-use crate::types::{GetUserGuildSchema, Guild, Snowflake};
+use crate::types::{GetUserGuildSchema, Guild, LimitType, Snowflake};
 
 impl ChorusUser {
     /// Leaves a given guild.
@@ -26,7 +25,7 @@ impl ChorusUser {
                 .header("Authorization", self.token())
                 .header("Content-Type", "application/json")
                 .body(to_string(&lurking).unwrap()),
-            limit_type: crate::api::LimitType::Guild(*guild_id),
+            limit_type: LimitType::Guild(*guild_id),
         }
         .handle_request_as_result(self)
         .await

src/api/users/relationships.rs

@@ -2,12 +2,12 @@ use reqwest::Client;
 use serde_json::to_string;
 
 use crate::{
-    api::LimitType,
     errors::ChorusResult,
     instance::ChorusUser,
     ratelimiter::ChorusRequest,
     types::{
-        self, CreateUserRelationshipSchema, FriendRequestSendSchema, RelationshipType, Snowflake,
+        self, CreateUserRelationshipSchema, FriendRequestSendSchema, LimitType, RelationshipType,
+        Snowflake,
     },
 };
 

src/api/users/users.rs

@@ -4,11 +4,10 @@ use reqwest::Client;
 use serde_json::to_string;
 
 use crate::{
-    api::LimitType,
     errors::{ChorusError, ChorusResult},
     instance::{ChorusUser, Instance},
     ratelimiter::ChorusRequest,
-    types::{User, UserModifySchema, UserSettings},
+    types::{LimitType, User, UserModifySchema, UserSettings},
 };
 
 impl ChorusUser {

src/instance.rs

@@ -8,12 +8,11 @@ use std::sync::{Arc, RwLock};
 use reqwest::Client;
 use serde::{Deserialize, Serialize};
 
-use crate::api::{Limit, LimitType};
 use crate::errors::ChorusResult;
 use crate::gateway::{Gateway, GatewayHandle};
 use crate::ratelimiter::ChorusRequest;
 use crate::types::types::subconfigs::limits::rates::RateLimits;
-use crate::types::{GeneralConfiguration, User, UserSettings};
+use crate::types::{GeneralConfiguration, Limit, LimitType, User, UserSettings};
 use crate::UrlBundle;
 
 #[derive(Debug, Clone)]

src/ratelimiter.rs

@@ -8,10 +8,9 @@ use serde::Deserialize;
 use serde_json::from_str;
 
 use crate::{
-    api::{Limit, LimitType},
     errors::{ChorusError, ChorusResult},
     instance::ChorusUser,
-    types::{types::subconfigs::limits::rates::RateLimits, LimitsConfiguration},
+    types::{types::subconfigs::limits::rates::RateLimits, Limit, LimitType, LimitsConfiguration},
 };
 
 /// Chorus' request struct. This struct is used to send rate-limited requests to the Spacebar server.

src/types/config/types/subconfigs/limits/rates.rs

@@ -2,11 +2,9 @@ use std::collections::HashMap;
 
 use serde::{Deserialize, Serialize};
 
-use crate::{
+use crate::types::{
-    api::LimitType,
+    config::types::subconfigs::limits::ratelimits::{route::RouteRateLimit, RateLimitOptions},
-    types::config::types::subconfigs::limits::ratelimits::{
+    LimitType,
-        route::RouteRateLimit, RateLimitOptions,
-    },
 };
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]

src/types/entities/auto_moderation.rs

@@ -1,13 +1,18 @@
 use std::sync::{Arc, RwLock};
 
+#[cfg(feature = "client")]
 use crate::gateway::Updateable;
+
+#[cfg(feature = "client")]
 use chorus_macros::Updateable;
+
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
 
 use crate::types::utils::Snowflake;
 
-#[derive(Serialize, Deserialize, Debug, Default, Clone, Updateable)]
+#[cfg_attr(feature = "client", derive(Updateable))]
+#[derive(Serialize, Deserialize, Debug, Default, Clone)]
 /// See <https://discord.com/developers/docs/resources/auto-moderation#auto-moderation-rule-object>
 pub struct AutoModerationRule {
     pub id: Snowflake,

src/types/entities/channel.rs

@@ -1,21 +1,28 @@
 use std::sync::{Arc, RwLock};
 
-use chorus_macros::{observe_option_vec, Composite, Updateable};
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use serde_aux::prelude::deserialize_string_from_number;
 use serde_repr::{Deserialize_repr, Serialize_repr};
 use std::fmt::Debug;
 
-use crate::gateway::{GatewayHandle, Updateable};
 use crate::types::{
     entities::{GuildMember, User},
     utils::Snowflake,
-    Composite,
 };
 
-#[derive(Default, Debug, Serialize, Deserialize, Clone, Updateable, Composite)]
+#[cfg(feature = "client")]
+use crate::types::Composite;
+
+#[cfg(feature = "client")]
+use crate::gateway::{GatewayHandle, Updateable};
+
+#[cfg(feature = "client")]
+use chorus_macros::{observe_option_vec, Composite, Updateable};
+
+#[derive(Default, Debug, Serialize, Deserialize, Clone)]
 #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
+#[cfg_attr(feature = "client", derive(Updateable, Composite))]
 /// Represents a guild or private channel
 ///
 /// # Reference
@@ -60,13 +67,13 @@ pub struct Channel {
     #[cfg(feature = "sqlx")]
     pub permission_overwrites: Option<sqlx::types::Json<Vec<PermissionOverwrite>>>,
     #[cfg(not(feature = "sqlx"))]
-    #[observe_option_vec]
+    #[cfg_attr(feature = "client", observe_option_vec)]
     pub permission_overwrites: Option<Vec<Arc<RwLock<PermissionOverwrite>>>>,
     pub permissions: Option<String>,
     pub position: Option<i32>,
     pub rate_limit_per_user: Option<i32>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    #[observe_option_vec]
+    #[cfg_attr(feature = "client", observe_option_vec)]
     pub recipients: Option<Vec<Arc<RwLock<User>>>>,
     pub rtc_region: Option<String>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
@@ -126,9 +133,8 @@ pub struct Tag {
     pub emoji_name: Option<String>,
 }
 
-#[derive(
+#[derive(Debug, Serialize, Deserialize, Clone, PartialEq, Eq, PartialOrd)]
-    Debug, Serialize, Deserialize, Clone, PartialEq, Eq, PartialOrd, Updateable, Composite,
+#[cfg_attr(feature = "client", derive(Updateable, Composite))]
-)]
 pub struct PermissionOverwrite {
     pub id: Snowflake,
     #[serde(rename = "type")]

src/types/entities/emoji.rs

@@ -1,14 +1,22 @@
 use std::fmt::Debug;
 use std::sync::{Arc, RwLock};
 
-use chorus_macros::{Composite, Updateable};
 use serde::{Deserialize, Serialize};
 
-use crate::gateway::{GatewayHandle, Updateable};
 use crate::types::entities::User;
-use crate::types::{Composite, Snowflake};
+use crate::types::Snowflake;
 
-#[derive(Debug, Clone, Deserialize, Serialize, Default, Updateable, Composite)]
+#[cfg(feature = "client")]
+use crate::types::Composite;
+
+#[cfg(feature = "client")]
+use crate::gateway::{GatewayHandle, Updateable};
+
+#[cfg(feature = "client")]
+use chorus_macros::{Composite, Updateable};
+
+#[derive(Debug, Clone, Deserialize, Serialize, Default)]
+#[cfg_attr(feature = "client", derive(Updateable, Composite))]
 #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
 /// # Reference
 /// See <https://discord-userdoccers.vercel.app/resources/emoji#emoji-object>

src/types/entities/guild.rs

@@ -1,25 +1,32 @@
 use std::fmt::Debug;
 use std::sync::{Arc, RwLock};
 
-use chorus_macros::{observe_option_vec, observe_vec, Composite, Updateable};
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use serde_repr::{Deserialize_repr, Serialize_repr};
 
-use crate::gateway::{GatewayHandle, Updateable};
 use crate::types::types::guild_configuration::GuildFeaturesList;
 use crate::types::{
     entities::{Channel, Emoji, RoleObject, Sticker, User, VoiceState, Webhook},
     interfaces::WelcomeScreenObject,
     utils::Snowflake,
-    Composite,
 };
 use bitflags::bitflags;
 
 use super::PublicUser;
 
+#[cfg(feature = "client")]
+use crate::gateway::{GatewayHandle, Updateable};
+
+#[cfg(feature = "client")]
+use chorus_macros::{observe_option_vec, observe_vec, Composite, Updateable};
+
+#[cfg(feature = "client")]
+use crate::types::Composite;
+
 /// See <https://discord.com/developers/docs/resources/guild>
-#[derive(Serialize, Deserialize, Debug, Default, Clone, Updateable, Composite)]
+#[derive(Serialize, Deserialize, Debug, Default, Clone)]
+#[cfg_attr(feature = "client", derive(Updateable, Composite))]
 #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
 pub struct Guild {
     pub afk_channel_id: Option<Snowflake>,
@@ -34,14 +41,14 @@ pub struct Guild {
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub bans: Option<Vec<GuildBan>>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    #[observe_option_vec]
+    #[cfg_attr(feature = "client", observe_option_vec)]
     pub channels: Option<Vec<Arc<RwLock<Channel>>>>,
     pub default_message_notifications: Option<MessageNotificationLevel>,
     pub description: Option<String>,
     pub discovery_splash: Option<String>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
+    #[cfg_attr(feature = "client", observe_vec)]
     #[serde(default)]
-    #[observe_vec]
     pub emojis: Vec<Arc<RwLock<Emoji>>>,
     pub explicit_content_filter: Option<i32>,
     //#[cfg_attr(feature = "sqlx", sqlx(try_from = "String"))]
@@ -77,7 +84,7 @@ pub struct Guild {
     pub public_updates_channel_id: Option<Snowflake>,
     pub region: Option<String>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    #[observe_option_vec]
+    #[cfg_attr(feature = "client", observe_option_vec)]
     pub roles: Option<Vec<Arc<RwLock<RoleObject>>>>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
     pub rules_channel: Option<String>,
@@ -91,10 +98,10 @@ pub struct Guild {
     pub vanity_url_code: Option<String>,
     pub verification_level: Option<VerificationLevel>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    #[observe_option_vec]
+    #[cfg_attr(feature = "client", observe_option_vec)]
     pub voice_states: Option<Vec<Arc<RwLock<VoiceState>>>>,
     #[cfg_attr(feature = "sqlx", sqlx(skip))]
-    #[observe_option_vec]
+    #[cfg_attr(feature = "client", observe_option_vec)]
     pub webhooks: Option<Vec<Arc<RwLock<Webhook>>>>,
     #[cfg(feature = "sqlx")]
     pub welcome_screen: Option<sqlx::types::Json<WelcomeScreenObject>>,

src/types/entities/mod.rs

@@ -10,6 +10,7 @@ pub use guild_member::*;
 pub use integration::*;
 pub use invite::*;
 pub use message::*;
+pub use ratelimits::*;
 pub use relationship::*;
 pub use role::*;
 pub use security_key::*;
@@ -22,9 +23,16 @@ pub use user_settings::*;
 pub use voice_state::*;
 pub use webhook::*;
 
+#[cfg(feature = "client")]
 use crate::gateway::{GatewayHandle, Updateable};
+
+#[cfg(feature = "client")]
 use async_trait::async_trait;
+
+#[cfg(feature = "client")]
 use std::fmt::Debug;
+
+#[cfg(feature = "client")]
 use std::sync::{Arc, RwLock};
 
 mod application;
@@ -39,6 +47,7 @@ mod guild_member;
 mod integration;
 mod invite;
 mod message;
+mod ratelimits;
 mod relationship;
 mod role;
 mod security_key;
@@ -51,6 +60,7 @@ mod user_settings;
 mod voice_state;
 mod webhook;
 
+#[cfg(feature = "client")]
 #[async_trait(?Send)]
 pub trait Composite<T: Updateable + Clone + Debug> {
     async fn watch_whole(self, gateway: &GatewayHandle) -> Self;

src/types/entities/role.rs

@@ -1,13 +1,21 @@
 use bitflags::bitflags;
-use chorus_macros::{Composite, Updateable};
 use serde::{Deserialize, Serialize};
 use serde_aux::prelude::{deserialize_option_number_from_string, deserialize_string_from_number};
 use std::fmt::Debug;
 
-use crate::gateway::{GatewayHandle, Updateable};
+use crate::types::utils::Snowflake;
-use crate::types::{utils::Snowflake, Composite};
 
-#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq, Updateable, Composite)]
+#[cfg(feature = "client")]
+use chorus_macros::{Composite, Updateable};
+
+#[cfg(feature = "client")]
+use crate::gateway::{GatewayHandle, Updateable};
+
+#[cfg(feature = "client")]
+use crate::types::Composite;
+
+#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq)]
+#[cfg_attr(feature = "client", derive(Updateable, Composite))]
 #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
 /// See <https://discord.com/developers/docs/topics/permissions#role-object>
 pub struct RoleObject {

src/types/entities/user.rs

@@ -1,11 +1,17 @@
-use chorus_macros::{Composite, Updateable};
+use crate::types::utils::Snowflake;
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use serde_aux::prelude::deserialize_option_number_from_string;
 use std::fmt::Debug;
 
+#[cfg(feature = "client")]
 use crate::gateway::{GatewayHandle, Updateable};
-use crate::types::{utils::Snowflake, Composite};
+
+#[cfg(feature = "client")]
+use crate::types::Composite;
+
+#[cfg(feature = "client")]
+use chorus_macros::{Composite, Updateable};
 
 use super::Emoji;
 
@@ -21,7 +27,8 @@ impl User {
         PublicUser::from(self)
     }
 }
-#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq, Updateable, Composite)]
+#[derive(Serialize, Deserialize, Debug, Default, Clone, PartialEq, Eq)]
+#[cfg_attr(feature = "client", derive(Updateable, Composite))]
 #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
 pub struct User {
     pub id: Snowflake,

src/types/entities/user_settings.rs

@@ -53,15 +53,17 @@ pub struct UserSettings {
     pub friend_source_flags: sqlx::types::Json<FriendSourceFlags>,
     #[cfg(not(feature = "sqlx"))]
     pub friend_source_flags: FriendSourceFlags,
-    pub gateway_connected: bool,
+    pub gateway_connected: Option<bool>,
     pub gif_auto_play: bool,
     #[cfg(feature = "sqlx")]
     pub guild_folders: sqlx::types::Json<Vec<GuildFolder>>,
     #[cfg(not(feature = "sqlx"))]
     pub guild_folders: Vec<GuildFolder>,
     #[cfg(feature = "sqlx")]
+    #[serde(default)]
     pub guild_positions: sqlx::types::Json<Vec<String>>,
     #[cfg(not(feature = "sqlx"))]
+    #[serde(default)]
     pub guild_positions: Vec<String>,
     pub inline_attachment_media: bool,
     pub inline_embed_media: bool,
@@ -98,7 +100,7 @@ impl Default for UserSettings {
             enable_tts_command: false,
             explicit_content_filter: 0,
             friend_source_flags: Default::default(),
-            gateway_connected: false,
+            gateway_connected: Some(false),
             gif_auto_play: false,
             guild_folders: Default::default(),
             guild_positions: Default::default(),

src/types/entities/voice_state.rs

@@ -1,20 +1,27 @@
 use std::sync::{Arc, RwLock};
 
+#[cfg(feature = "client")]
 use chorus_macros::{Composite, Updateable};
+
+#[cfg(feature = "client")]
+use crate::types::Composite;
+
+#[cfg(feature = "client")]
+use crate::gateway::{GatewayHandle, Updateable};
+
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 use std::fmt::Debug;
 
-use crate::gateway::{GatewayHandle, Updateable};
 use crate::types::{
     entities::{Guild, GuildMember},
     utils::Snowflake,
-    Composite,
 };
 
 /// See <https://docs.spacebar.chat/routes/#cmp--schemas-voicestate>
-#[derive(Serialize, Deserialize, Debug, Default, Clone, Updateable, Composite)]
+#[derive(Serialize, Deserialize, Debug, Default, Clone)]
 #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
+#[cfg_attr(feature = "client", derive(Updateable, Composite))]
 pub struct VoiceState {
     pub guild_id: Option<Snowflake>,
     pub guild: Option<Guild>,

src/types/entities/webhook.rs

@@ -1,18 +1,25 @@
 use std::fmt::Debug;
 use std::sync::{Arc, RwLock};
 
-use chorus_macros::{Composite, Updateable};
 use serde::{Deserialize, Serialize};
 
+#[cfg(feature = "client")]
 use crate::gateway::{GatewayHandle, Updateable};
+
+#[cfg(feature = "client")]
+use chorus_macros::{Composite, Updateable};
+
+#[cfg(feature = "client")]
+use crate::types::Composite;
+
 use crate::types::{
     entities::{Guild, User},
     utils::Snowflake,
-    Composite,
 };
 
 /// See <https://docs.spacebar.chat/routes/#cmp--schemas-webhook>
-#[derive(Serialize, Deserialize, Debug, Default, Clone, Updateable, Composite)]
+#[derive(Serialize, Deserialize, Debug, Default, Clone)]
+#[cfg_attr(feature = "client", derive(Updateable, Composite))]
 #[cfg_attr(feature = "sqlx", derive(sqlx::FromRow))]
 pub struct Webhook {
     pub id: Snowflake,

src/types/events/auto_moderation.rs

@@ -7,6 +7,7 @@ use crate::types::{
     WebSocketEvent,
 };
 
+#[cfg(feature = "client")]
 use super::UpdateMessage;
 
 #[derive(Debug, Deserialize, Serialize, Default, Clone)]
@@ -27,6 +28,7 @@ pub struct AutoModerationRuleUpdate {
     pub json: String,
 }
 
+#[cfg(feature = "client")]
 impl UpdateMessage<AutoModerationRule> for AutoModerationRuleUpdate {
     fn id(&self) -> Option<Snowflake> {
         Some(self.rule.id)

src/types/events/channel.rs

@@ -1,14 +1,18 @@
-use std::sync::{Arc, RwLock};
-
 use crate::types::events::WebSocketEvent;
-use crate::types::Guild;
 use crate::types::{entities::Channel, JsonField, Snowflake};
 use chorus_macros::JsonField;
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
 
+#[cfg(feature = "client")]
 use super::UpdateMessage;
 
+#[cfg(feature = "client")]
+use std::sync::{Arc, RwLock};
+
+#[cfg(feature = "client")]
+use crate::types::Guild;
+
 #[derive(Debug, Default, Deserialize, Serialize)]
 /// See <https://discord.com/developers/docs/topics/gateway-events#channel-pins-update>
 pub struct ChannelPinsUpdate {
@@ -30,6 +34,7 @@ pub struct ChannelCreate {
 
 impl WebSocketEvent for ChannelCreate {}
 
+#[cfg(feature = "client")]
 impl UpdateMessage<Guild> for ChannelCreate {
     fn id(&self) -> Option<Snowflake> {
         self.channel.guild_id
@@ -57,6 +62,7 @@ pub struct ChannelUpdate {
 
 impl WebSocketEvent for ChannelUpdate {}
 
+#[cfg(feature = "client")]
 impl UpdateMessage<Channel> for ChannelUpdate {
     fn update(&mut self, object_to_update: Arc<RwLock<Channel>>) {
         let mut write = object_to_update.write().unwrap();
@@ -96,6 +102,7 @@ pub struct ChannelDelete {
     pub json: String,
 }
 
+#[cfg(feature = "client")]
 impl UpdateMessage<Guild> for ChannelDelete {
     fn id(&self) -> Option<Snowflake> {
         self.channel.guild_id

src/types/events/guild.rs

@@ -1,5 +1,3 @@
-use std::sync::{Arc, RwLock};
-
 use chorus_macros::JsonField;
 use chrono::{DateTime, Utc};
 use serde::{Deserialize, Serialize};
@@ -11,7 +9,12 @@ use crate::types::{
     Sticker,
 };
 
-use super::{PresenceUpdate, UpdateMessage};
+use super::PresenceUpdate;
+
+#[cfg(feature = "client")]
+use super::UpdateMessage;
+#[cfg(feature = "client")]
+use std::sync::{Arc, RwLock};
 
 #[derive(Debug, Deserialize, Serialize, Default, Clone)]
 /// See <https://discord.com/developers/docs/topics/gateway-events#guild-create>;
@@ -179,6 +182,7 @@ pub struct GuildRoleCreate {
 
 impl WebSocketEvent for GuildRoleCreate {}
 
+#[cfg(feature = "client")]
 impl UpdateMessage<Guild> for GuildRoleCreate {
     fn id(&self) -> Option<Snowflake> {
         Some(self.guild_id)
@@ -209,6 +213,7 @@ pub struct GuildRoleUpdate {
 
 impl WebSocketEvent for GuildRoleUpdate {}
 
+#[cfg(feature = "client")]
 impl UpdateMessage<RoleObject> for GuildRoleUpdate {
     fn id(&self) -> Option<Snowflake> {
         Some(self.role.id)

src/types/events/mod.rs

@@ -1,12 +1,5 @@
-use std::sync::{Arc, RwLock};
-
-use std::collections::HashMap;
-
-use serde::de::DeserializeOwned;
 use serde::{Deserialize, Serialize};
 
-use serde_json::{from_str, from_value, to_value, Value};
-
 pub use application::*;
 pub use auto_moderation::*;
 pub use call::*;
@@ -34,9 +27,23 @@ pub use voice::*;
 pub use webhooks::*;
 pub use webrtc::*;
 
+#[cfg(feature = "client")]
+use super::Snowflake;
+
+#[cfg(feature = "client")]
 use crate::gateway::Updateable;
 
-use super::Snowflake;
+#[cfg(feature = "client")]
+use serde_json::{from_str, from_value, to_value, Value};
+
+#[cfg(feature = "client")]
+use std::collections::HashMap;
+
+#[cfg(feature = "client")]
+use std::sync::{Arc, RwLock};
+
+#[cfg(feature = "client")]
+use serde::de::DeserializeOwned;
 
 mod application;
 mod auto_moderation;
@@ -107,6 +114,7 @@ pub struct GatewayReceivePayload<'a> {
 
 impl<'a> WebSocketEvent for GatewayReceivePayload<'a> {}
 
+#[cfg(feature = "client")]
 /// An [`UpdateMessage<T>`] represents a received Gateway Message which contains updated
 /// information for an [`Updateable`] of Type T.
 /// # Example:
@@ -134,6 +142,7 @@ pub(crate) trait JsonField: Clone {
     fn get_json(&self) -> String;
 }
 
+#[cfg(feature = "client")]
 /// Only applicable for events where the Update struct is the same as the Entity struct
 pub(crate) fn update_object(
     value: String,

src/types/events/thread.rs

@@ -5,6 +5,7 @@ use crate::types::entities::{Channel, ThreadMember};
 use crate::types::events::WebSocketEvent;
 use crate::types::{JsonField, Snowflake};
 
+#[cfg(feature = "client")]
 use super::UpdateMessage;
 
 #[derive(Debug, Default, Deserialize, Serialize, Clone)]
@@ -27,6 +28,7 @@ pub struct ThreadUpdate {
 
 impl WebSocketEvent for ThreadUpdate {}
 
+#[cfg(feature = "client")]
 impl UpdateMessage<Channel> for ThreadUpdate {
     fn id(&self) -> Option<Snowflake> {
         Some(self.thread.id)