Refactor things a bit to be less annoying

src/commands.rs

@@ -0,0 +1,125 @@
+use axum::http::StatusCode;
+use sqlx::PgPool;
+use twilight_interactions::command::{CommandModel, CreateCommand};
+use twilight_mention::{Mention, timestamp::{TimestampStyle, Timestamp}};
+use twilight_model::{id::{Id, marker::{InteractionMarker, ChannelMarker, UserMarker}}, http::interaction::{InteractionResponse, InteractionResponseType, InteractionResponseData}, channel::message::MessageFlags};
+
+
+#[derive(CommandModel, CreateCommand)]
+#[command(name = "set_fact", desc = "Quietly save a fact")]
+pub struct SetFactCommand {
+    #[command(rename = "name", desc = "Fact name")]
+    fact_name: String,
+    #[command(rename = "value", desc = "Fact value")]
+    fact_value: String,
+}
+
+#[derive(CommandModel, CreateCommand)]
+#[command(name = "get_fact", desc = "Retrieve and display the value of a fact")]
+pub struct GetFactCommand {
+    #[command(rename = "name", desc = "Fact name")]
+    fact_name: String,
+    #[command(desc = "Should it be displayed publically, by default it won't be")]
+    public: Option<bool>,
+}
+
+
+pub async fn set_fact(
+    interaction_id: Id<InteractionMarker>,
+    channel_id: Option<Id<ChannelMarker>>,
+    author_id: Id<UserMarker>,
+    command_data: SetFactCommand,
+    pg_pool: &PgPool,
+) -> Result<InteractionResponse, (StatusCode, String)> {
+    let Ok(rows) = sqlx::query!("
+INSERT INTO facts (\"last_interaction_id\", \"channel_id\", \"author_id\", \"name\", \"value\") 
+VALUES ($1, $2, $3, $4, $5)
+ON CONFLICT ON CONSTRAINT facts_origin_key DO UPDATE SET value = $5, version = facts.version + 1
+    ",
+        interaction_id.to_string(),
+        channel_id.map(|cid| cid.to_string()),
+        author_id.to_string(),
+        command_data.fact_name,
+        command_data.fact_value,
+    ).execute(pg_pool).await.and_then(|rows| Ok(rows.rows_affected())) else {
+        return Err((StatusCode::INTERNAL_SERVER_ERROR, "Error saving fact.".to_string()));
+    };
+
+    if rows != 1 {
+        return Err((StatusCode::INTERNAL_SERVER_ERROR, "Error saving fact".to_string()));
+    }
+
+    Ok(InteractionResponse {
+        kind: InteractionResponseType::ChannelMessageWithSource,
+        data: Some(InteractionResponseData {
+            content: Some(format!(
+                "Set {0} to {1}",
+                command_data.fact_name, command_data.fact_value
+            )),
+            flags: Some(MessageFlags::EPHEMERAL),
+            ..Default::default()
+        }),
+    })
+}
+
+struct FactResponse {
+    value: String,
+    version: i32,
+    created_at: time::OffsetDateTime,
+    updated_at: time::OffsetDateTime,
+}
+
+pub async fn get_fact(
+    channel_id: Option<Id<ChannelMarker>>,
+    author_id: Id<UserMarker>,
+    command_data: GetFactCommand,
+    pg_pool: &PgPool,
+) -> Result<InteractionResponse, (StatusCode, String)> {
+    let Ok(facts) = sqlx::query_as!(FactResponse, 
+        "
+SELECT \"value\", \"version\", \"created_at\", \"updated_at\"
+FROM facts
+WHERE
+    channel_id IS NOT DISTINCT FROM $1 AND
+    author_id = $2 AND
+    name = $3
+        ", channel_id.map(|cid| cid.to_string()), author_id.to_string(), command_data.fact_name).fetch_all(pg_pool).await else {
+            return Err((StatusCode::INTERNAL_SERVER_ERROR, "Querying facts failed".to_string()));
+        };
+    if facts.len() == 0 {        
+        return Ok(InteractionResponse { 
+            kind: InteractionResponseType::ChannelMessageWithSource, 
+            data: Some(InteractionResponseData { 
+                content: Some(format!("Fact {0} in channel {1} by you, {2}, was not found.",
+                    command_data.fact_name,
+                    channel_id.map_or("<none>".to_string(), |cid| cid.mention().to_string()),
+                    author_id.mention().to_string(),
+                )),
+                flags: match command_data.public { Some(true) => None, _ => Some(MessageFlags::EPHEMERAL) },
+                ..Default::default()
+            }),
+        });
+    }
+    if facts.len() > 1 {
+        return Err((StatusCode::INTERNAL_SERVER_ERROR, "Too many facts found, wtf, impossible".to_string()));
+    }
+
+    let fact = &facts[0];
+
+    Ok(InteractionResponse {
+        kind: InteractionResponseType::ChannelMessageWithSource,
+        data: Some(InteractionResponseData {
+            content: Some(format!(
+                "Fact **{0}** was set to **{1}** by {2} at {3}, and was reset {4} times in total since {5}.",
+                command_data.fact_name, 
+                fact.value, 
+                author_id.mention().to_string(),
+                Timestamp::new(fact.updated_at.unix_timestamp().try_into().unwrap(), Some(TimestampStyle::RelativeTime)).mention(),
+                fact.version,
+                Timestamp::new(fact.created_at.unix_timestamp().try_into().unwrap(), Some(TimestampStyle::ShortDateTime)).mention(),
+            )),
+            flags: match command_data.public { Some(true) => None, _ => Some(MessageFlags::EPHEMERAL) },
+            ..Default::default()
+        }),
+    })
+}

src/main.rs

@@ -7,35 +7,19 @@ use axum::{
     Json, Router,
 };
 use base64::{alphabet, engine, Engine};
+use commands::{SetFactCommand, GetFactCommand, set_fact, get_fact};
 use ed25519_dalek::{Signature, VerifyingKey};
 use serde::Deserialize;
 use sqlx::{postgres::PgPoolOptions, PgPool};
 use twilight_http::Client;
 use twilight_interactions::command::{CommandInputData, CommandModel, CreateCommand};
-use twilight_mention::{timestamp::{Timestamp, TimestampStyle}, Mention};
+
 use twilight_model::{
     application::interaction::{Interaction, InteractionData, InteractionType},
-    http::interaction::{InteractionResponse, InteractionResponseData, InteractionResponseType},
+    http::interaction::{InteractionResponse, InteractionResponseType},
-    id::{Id, marker::{UserMarker, ChannelMarker, InteractionMarker}}, channel::message::MessageFlags,
+    id::Id
 };
-
+mod commands;
-#[derive(CommandModel, CreateCommand)]
-#[command(name = "set_fact", desc = "Quietly save a fact")]
-struct SetFactCommand {
-    #[command(rename = "name", desc = "Fact name")]
-    fact_name: String,
-    #[command(rename = "value", desc = "Fact value")]
-    fact_value: String,
-}
-
-#[derive(CommandModel, CreateCommand)]
-#[command(name = "get_fact", desc = "Retrieve and display the value of a fact")]
-struct GetFactCommand {
-    #[command(rename = "name", desc = "Fact name")]
-    fact_name: String,
-    #[command(desc = "Should it be displayed publically, by default it won't be")]
-    public: Option<bool>,
-}
 
 #[tokio::main]
 async fn main() -> anyhow::Result<()> {
@@ -93,106 +77,6 @@ fn validate_request(headers: HeaderMap, body: String) -> Result<Interaction, (St
     return Ok(interaction);
 }
 
-async fn set_fact(
-    interaction_id: Id<InteractionMarker>,
-    channel_id: Option<Id<ChannelMarker>>,
-    author_id: Id<UserMarker>,
-    command_data: SetFactCommand,
-    pg_pool: &PgPool,
-) -> Result<InteractionResponse, (StatusCode, String)> {
-    let Ok(rows) = sqlx::query!("
-INSERT INTO facts (\"last_interaction_id\", \"channel_id\", \"author_id\", \"name\", \"value\") 
-VALUES ($1, $2, $3, $4, $5)
-ON CONFLICT ON CONSTRAINT facts_origin_key DO UPDATE SET value = $5, version = facts.version + 1
-    ",
-        interaction_id.to_string(),
-        channel_id.map(|cid| cid.to_string()),
-        author_id.to_string(),
-        command_data.fact_name,
-        command_data.fact_value,
-    ).execute(pg_pool).await.and_then(|rows| Ok(rows.rows_affected())) else {
-        return Err((StatusCode::INTERNAL_SERVER_ERROR, "Error saving fact.".to_string()));
-    };
-
-    if rows != 1 {
-        return Err((StatusCode::INTERNAL_SERVER_ERROR, "Error saving fact".to_string()));
-    }
-
-    Ok(InteractionResponse {
-        kind: InteractionResponseType::ChannelMessageWithSource,
-        data: Some(InteractionResponseData {
-            content: Some(format!(
-                "Set {0} to {1}",
-                command_data.fact_name, command_data.fact_value
-            )),
-            flags: Some(MessageFlags::EPHEMERAL),
-            ..Default::default()
-        }),
-    })
-}
-
-struct FactResponse {
-    value: String,
-    version: i32,
-    created_at: time::OffsetDateTime,
-    updated_at: time::OffsetDateTime,
-}
-
-async fn get_fact(
-    channel_id: Option<Id<ChannelMarker>>,
-    author_id: Id<UserMarker>,
-    command_data: GetFactCommand,
-    pg_pool: &PgPool,
-) -> Result<InteractionResponse, (StatusCode, String)> {
-    let Ok(facts) = sqlx::query_as!(FactResponse, 
-        "
-SELECT \"value\", \"version\", \"created_at\", \"updated_at\"
-FROM facts
-WHERE
-    channel_id IS NOT DISTINCT FROM $1 AND
-    author_id = $2 AND
-    name = $3
-        ", channel_id.map(|cid| cid.to_string()), author_id.to_string(), command_data.fact_name).fetch_all(pg_pool).await else {
-            return Err((StatusCode::INTERNAL_SERVER_ERROR, "Querying facts failed".to_string()));
-        };
-    if facts.len() == 0 {        
-        return Ok(InteractionResponse { 
-            kind: InteractionResponseType::ChannelMessageWithSource, 
-            data: Some(InteractionResponseData { 
-                content: Some(format!("Fact {0} in channel {1} by you, {2}, was not found.",
-                    command_data.fact_name,
-                    channel_id.map_or("<none>".to_string(), |cid| cid.mention().to_string()),
-                    author_id.mention().to_string(),
-                )),
-                flags: match command_data.public { Some(true) => None, _ => Some(MessageFlags::EPHEMERAL) },
-                ..Default::default()
-            }),
-        });
-    }
-    if facts.len() > 1 {
-        return Err((StatusCode::INTERNAL_SERVER_ERROR, "Too many facts found, wtf, impossible".to_string()));
-    }
-
-    let fact = &facts[0];
-
-    Ok(InteractionResponse {
-        kind: InteractionResponseType::ChannelMessageWithSource,
-        data: Some(InteractionResponseData {
-            content: Some(format!(
-                "Fact **{0}** was set to **{1}** by {2} at {3}, and was reset {4} times in total since {5}.",
-                command_data.fact_name, 
-                fact.value, 
-                author_id.mention().to_string(),
-                Timestamp::new(fact.updated_at.unix_timestamp().try_into().unwrap(), Some(TimestampStyle::RelativeTime)).mention(),
-                fact.version,
-                Timestamp::new(fact.created_at.unix_timestamp().try_into().unwrap(), Some(TimestampStyle::ShortDateTime)).mention(),
-            )),
-            flags: match command_data.public { Some(true) => None, _ => Some(MessageFlags::EPHEMERAL) },
-            ..Default::default()
-        }),
-    })
-}
-
 async fn post_interaction(
     headers: HeaderMap,
     State(pg_pool): State<PgPool>,
@@ -218,24 +102,24 @@ async fn post_interaction(
             };
             let command_input_data = CommandInputData::from(*data.clone());
             match &*data.name {
-                "set_fact" => {
+                SetFactCommand::NAME => {
                     let Ok(command_data) = SetFactCommand::from_interaction(command_input_data) else {
-                        return Err((StatusCode::BAD_REQUEST, "invalid set fact command".to_string()));
+                        return Err((StatusCode::BAD_REQUEST, format!("invalid {0} command.", SetFactCommand::NAME)));
                     };
                     let Some(author_id) = author_id else {
-                        return Err((StatusCode::BAD_REQUEST, "save_fact requires a user".to_string()));
+                        return Err((StatusCode::BAD_REQUEST, format!("{0} requires a user.", SetFactCommand::NAME)));
                     };
                     match set_fact(interaction.id, interaction.channel_id, author_id, command_data, &pg_pool).await {
                         Ok(response) => Ok((StatusCode::OK, Json(response))),
                         Err(err) => Err(err),
                     }
                 },
-                "get_fact" => {
+                GetFactCommand::NAME => {
                     let Ok(command_data) = GetFactCommand::from_interaction(command_input_data) else {
-                        return Err((StatusCode::BAD_REQUEST, "invalid get fact command".to_string()));
+                        return Err((StatusCode::BAD_REQUEST, format!("invalid {0} command.", GetFactCommand::NAME)));
                     };
                     let Some(author_id) = author_id else {
-                        return Err((StatusCode::BAD_REQUEST, "get_fact requires a user".to_string()));
+                        return Err((StatusCode::BAD_REQUEST, format!("{0} requires a user.", GetFactCommand::NAME)));
                     };
                     
                     match get_fact(interaction.channel_id, author_id, command_data, &pg_pool).await {