Implement users in API

src/database/models/ids.rs

@@ -77,9 +77,16 @@ generate_ids!(
     pub generate_state_id,
     StateId,
     8,
-    "SELECT EXISTS(SELECT 1 FROM mods WHERE id=$1)",
+    "SELECT EXISTS(SELECT 1 FROM states WHERE id=$1)",
     StateId
 );
+generate_ids!(
+    pub generate_user_id,
+    UserId,
+    8,
+    "SELECT EXISTS(SELECT 1 FROM users WHERE id=$1)",
+    UserId
+);
 
 #[derive(Copy, Clone, Debug, Type)]
 #[sqlx(transparent)]

src/database/models/mod.rs

@@ -8,6 +8,7 @@ pub mod ids;
 pub mod mod_item;
 pub mod team_item;
 pub mod version_item;
+pub mod user_item;
 
 pub use ids::*;
 pub use mod_item::Mod;
@@ -16,6 +17,7 @@ pub use team_item::TeamMember;
 pub use version_item::FileHash;
 pub use version_item::Version;
 pub use version_item::VersionFile;
+pub use user_item::User;
 
 #[derive(Error, Debug)]
 pub enum DatabaseError {

src/database/models/user_item.rs

@@ -0,0 +1,115 @@
+use super::ids::UserId;
+
+pub struct User {
+    pub id: UserId,
+    pub github_id: UserId,
+    pub username: String,
+    pub name: String,
+    pub email: Option<String>,
+    pub avatar_url: String,
+    pub bio: String,
+    pub created: chrono::DateTime<chrono::Utc>,
+}
+
+impl User {
+    pub async fn insert(
+        &self,
+        transaction: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+    ) -> Result<(), sqlx::error::Error> {
+        sqlx::query!(
+            "
+            INSERT INTO users (
+                id, github_id, username, name, email,
+                avatar_url, bio, created
+            )
+            VALUES (
+                $1, $2, $3, $4, $5,
+                $6, $7, $8
+            )
+            ",
+            self.id as UserId,
+            self.github_id as UserId,
+            &self.username,
+            &self.name,
+            self.email.as_ref(),
+            &self.avatar_url,
+            &self.bio,
+            self.created,
+        )
+            .execute(&mut *transaction)
+            .await?;
+
+        Ok(())
+    }
+    pub async fn get<'a, 'b, E>(
+        id: UserId,
+        executor: E,
+    ) -> Result<Option<Self>, sqlx::error::Error>
+        where
+            E: sqlx::Executor<'a, Database = sqlx::Postgres>,
+    {
+        let result = sqlx::query!(
+            "
+            SELECT u.github_id, u.name, u.email,
+                u.avatar_url, u.username, u.bio,
+                u.created
+            FROM users u
+            WHERE u.id = $1
+            ",
+            id as UserId,
+        )
+            .fetch_optional(executor)
+            .await?;
+
+        if let Some(row) = result {
+            Ok(Some(User {
+                id,
+                github_id: UserId(row.github_id),
+                name: row.name,
+                email: row.email,
+                avatar_url: row.avatar_url,
+                username: row.username,
+                bio: row.bio,
+                created: row.created,
+            }))
+        } else {
+            Ok(None)
+        }
+    }
+
+    pub async fn get_from_github_id<'a, 'b, E>(
+        github_id: UserId,
+        executor: E,
+    ) -> Result<Option<Self>, sqlx::error::Error>
+        where
+            E: sqlx::Executor<'a, Database = sqlx::Postgres>,
+    {
+        let result = sqlx::query!(
+            "
+            SELECT u.id, u.name, u.email,
+                u.avatar_url, u.username, u.bio,
+                u.created
+            FROM users u
+            WHERE u.github_id = $1
+            ",
+            github_id as UserId,
+        )
+            .fetch_optional(executor)
+            .await?;
+
+        if let Some(row) = result {
+            Ok(Some(User {
+                id: UserId(row.id),
+                github_id,
+                name: row.name,
+                email: row.email,
+                avatar_url: row.avatar_url,
+                username: row.username,
+                bio: row.bio,
+                created: row.created,
+            }))
+        } else {
+            Ok(None)
+        }
+    }
+}