Send help, im stuck in life time hell

migrations/20250913111615_missions.up.sql

@@ -2,6 +2,8 @@ CREATE TABLE IF NOT EXISTS missions (
     id BIGSERIAL PRIMARY KEY NOT NULL,
     name TEXT NOT NULL,
     description TEXT NOT NULL,
+    starting_at BIGINT NOT NULL,
+    estimated_length BIGINT NOT NULL,
     created_at BIGINT NOT NULL,
     modified_at BIGINT NOT NULL
 );

migrations/20250913130129_attendance.down.sql

@@ -0,0 +1 @@
+DROP TABLE IF EXISTS attendance;

migrations/20250913130129_attendance.up.sql

@@ -0,0 +1,10 @@
+CREATE TABLE IF NOT EXISTS attendance (
+    id BIGSERIAL PRIMARY KEY NOT NULL,
+    user_id BIGINT NOT NULL,
+    mission_id BIGINT NOT NULL,
+    confirmed_at BIGINT NOT NULL,
+    attending BOOL NOT NULL,
+
+    CONSTRAINT fk_user FOREIGN KEY (user_id) REFERENCES users(id) ON DELETE SET NULL,
+    CONSTRAINT fk_mission FOREIGN KEY (mission_id) REFERENCES missions(id) ON DELETE CASCADE
+);

src/api/user/mod.rs

@@ -9,7 +9,10 @@ pub mod login;
 pub mod register;
 
 pub fn register_routes() -> Router<Database> {
+    let sub_methods = Router::new();
+    // .route("/awards", method_router);
     Router::new()
         .route("/register", post(register::route))
         .route("/login", post(login::route))
+        .nest("/{id}", sub_methods)
 }

src/db/mod.rs

@@ -3,7 +3,8 @@ use sqlx::{Pool, Postgres, postgres::PgPoolOptions};
 
 pub mod tables;
 
-pub type CurrPool = Pool<Postgres>;
+pub type CurrDb = Postgres;
+pub type CurrPool = Pool<CurrDb>;
 
 #[derive(Debug, Clone)]
 pub struct Database {

src/db/tables/assignables/awards.rs

@@ -1,8 +1,9 @@
 use anyhow::Result;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
+use crate::db::{CurrPool, tables::TableMeta};
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, FromRow)]
 pub struct Award {
     pub id: i64,
     pub name: String,
@@ -11,6 +12,11 @@ pub struct Award {
     pub modified_at: i64,
 }
 
+impl TableMeta<'_> for Award {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "awards";
+}
+
 impl Award {
     pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
         let session = sqlx::query_as!(

src/db/tables/assignables/missions.rs

@@ -1,16 +1,24 @@
 use anyhow::Result;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
+use crate::db::{CurrPool, tables::TableMeta};
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, FromRow)]
 pub struct Mission {
     pub id: i64,
     pub name: String,
     pub description: String,
+    pub starting_at: i64,
+    pub estimated_length: i64,
     pub created_at: i64,
     pub modified_at: i64,
 }
 
+impl TableMeta<'_> for Mission {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "missions";
+}
+
 impl Mission {
     pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
         let session = sqlx::query_as!(

src/db/tables/assignables/qualifications.rs

@@ -1,8 +1,9 @@
 use anyhow::Result;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
+use crate::db::{CurrPool, tables::TableMeta};
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, FromRow)]
 pub struct Qualification {
     pub id: i64,
     pub name: String,
@@ -11,6 +12,11 @@ pub struct Qualification {
     pub modified_at: i64,
 }
 
+impl TableMeta<'_> for Qualification {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "qualifications";
+}
+
 impl Qualification {
     pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
         let session = sqlx::query_as!(

src/db/tables/assignables/ranks.rs

@@ -1,8 +1,9 @@
 use anyhow::Result;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
+use crate::db::{CurrPool, tables::TableMeta};
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, FromRow)]
 pub struct Rank {
     pub id: i64,
     pub name: String,
@@ -11,6 +12,11 @@ pub struct Rank {
     pub modified_at: i64,
 }
 
+impl TableMeta<'_> for Rank {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "ranks";
+}
+
 impl Rank {
     pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
         let session = sqlx::query_as!(

src/db/tables/assignables/trainings.rs

@@ -1,8 +1,9 @@
 use anyhow::Result;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
+use crate::db::{CurrPool, tables::TableMeta};
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, FromRow)]
 pub struct Training {
     pub id: i64,
     pub name: String,
@@ -11,6 +12,11 @@ pub struct Training {
     pub modified_at: i64,
 }
 
+impl TableMeta<'_> for Training {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "trainings";
+}
+
 impl Training {
     pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
         let session = sqlx::query_as!(

src/db/tables/mod.rs

@@ -1,4 +1,82 @@
+use std::{
+    error::Error,
+    marker::PhantomData,
+    ops::{Deref, DerefMut},
+};
+
+use sqlx::{Decode, Encode, QueryBuilder, Type, postgres::PgRow};
+
 pub mod assignables;
+pub mod attendance;
 pub mod records;
 pub mod sessions;
 pub mod user;
+
+pub trait TableMeta<'a>: for<'r> sqlx::FromRow<'r, PgRow> {
+    type PrimaryKey: Encode<'a, super::CurrDb> + Type<super::CurrDb> + Clone;
+    const TABLE: &'static str;
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct ForeignKey<'a, FK: TableMeta<'a>> {
+    id: FK::PrimaryKey,
+    _ft: PhantomData<FK>,
+}
+
+impl<'a, FK: TableMeta<'a> + Send + for<'r> sqlx::FromRow<'r, PgRow> + Unpin + 'a>
+    ForeignKey<'a, FK>
+{
+    pub async fn extract(&self, db: &super::CurrPool) -> anyhow::Result<FK> {
+        let id = self.id.clone();
+
+        let res = QueryBuilder::new("")
+            .push(format!("SELECT * FROM {} WHERE id = ", FK::TABLE))
+            .push_bind(id)
+            .build_query_as::<FK>()
+            .fetch_one(db)
+            .await?;
+
+        Ok(res)
+    }
+}
+
+impl<'a, TM: TableMeta<'a>> Type<super::CurrDb> for ForeignKey<'a, TM> {
+    fn type_info() -> <super::CurrDb as sqlx::Database>::TypeInfo {
+        TM::PrimaryKey::type_info()
+    }
+}
+
+impl<'a, TM: TableMeta<'a>> Decode<'a, super::CurrDb> for ForeignKey<'a, TM>
+where
+    &'a str: Decode<'a, super::CurrDb>,
+    <TM as TableMeta<'a>>::PrimaryKey: sqlx::Decode<'a, super::CurrDb>,
+{
+    fn decode(
+        value: <super::CurrDb as sqlx::Database>::ValueRef<'a>,
+    ) -> Result<Self, Box<dyn Error + 'static + Send + Sync>> {
+        <TM::PrimaryKey as Decode<super::CurrDb>>::decode(value);
+        todo!()
+    }
+}
+
+impl<'a, TM: TableMeta<'a>> Deref for ForeignKey<'a, TM> {
+    type Target = TM::PrimaryKey;
+    fn deref(&self) -> &Self::Target {
+        &self.id
+    }
+}
+
+impl<'a, TM: TableMeta<'a>> DerefMut for ForeignKey<'a, TM> {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.id
+    }
+}
+
+impl<'a, FK: TableMeta<'a, PrimaryKey = i64>> From<i64> for ForeignKey<'a, FK> {
+    fn from(value: FK::PrimaryKey) -> Self {
+        Self {
+            id: value,
+            _ft: PhantomData,
+        }
+    }
+}

src/db/tables/records/awards.rs

@@ -1,17 +1,26 @@
 use anyhow::Result;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
+use crate::db::{
+    CurrPool,
+    tables::{ForeignKey, TableMeta, assignables::awards::Award, user::User},
+};
 
-#[derive(Debug, Default, Clone)]
-pub struct AwardRecord {
+#[derive(Debug, Default, Clone, FromRow)]
+pub struct AwardRecord<'a> {
     pub id: i64,
-    pub user_id: i64,
-    pub award_id: i64,
-    pub author_id: i64,
+    pub user_id: ForeignKey<'a, User>,
+    pub award_id: ForeignKey<'a, Award>,
+    pub author_id: ForeignKey<'a, User>,
     pub created_at: i64,
 }
 
-impl AwardRecord {
+impl<'a> TableMeta<'a> for AwardRecord<'a> {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "records_awards";
+}
+
+impl AwardRecord<'_> {
     pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
         let session = sqlx::query_as!(
             AwardRecord,
@@ -20,14 +29,16 @@ impl AwardRecord {
                 VALUES ($1, $2, $3, $4)
                 RETURNING *
             "#,
-            self.user_id,
-            self.award_id,
-            self.author_id,
+            *self.user_id,
+            *self.award_id,
+            *self.author_id,
             self.created_at,
         )
         .fetch_one(pool)
         .await?;
 
+        self.author_id.extract(pool);
+
         Ok(session)
     }
     pub async fn get_by_id(pool: &CurrPool, id: i64) -> anyhow::Result<Self> {

src/db/tables/records/missions.rs

@@ -1,17 +1,26 @@
 use anyhow::Result;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
+use crate::db::{
+    CurrPool,
+    tables::{ForeignKey, TableMeta, assignables::missions::Mission, user::User},
+};
 
-#[derive(Debug, Default, Clone)]
-pub struct MissionRecord {
+#[derive(Debug, Default, Clone, FromRow)]
+pub struct MissionRecord<'a> {
     pub id: i64,
-    pub user_id: i64,
-    pub mission_id: i64,
-    pub author_id: i64,
+    pub user_id: ForeignKey<'a, User>,
+    pub mission_id: ForeignKey<'a, Mission>,
+    pub author_id: ForeignKey<'a, User>,
     pub created_at: i64,
 }
 
-impl MissionRecord {
+impl TableMeta<'_> for MissionRecord<'_> {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "records_missions";
+}
+
+impl MissionRecord<'_> {
     pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
         let session = sqlx::query_as!(
             MissionRecord,
@@ -20,9 +29,9 @@ impl MissionRecord {
                 VALUES ($1, $2, $3, $4)
                 RETURNING *
             "#,
-            self.user_id,
-            self.mission_id,
-            self.author_id,
+            *self.user_id,
+            *self.mission_id,
+            *self.author_id,
             self.created_at,
         )
         .fetch_one(pool)

src/db/tables/records/qualifications.rs

@@ -1,17 +1,26 @@
 use anyhow::Result;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
+use crate::db::{
+    CurrPool,
+    tables::{ForeignKey, TableMeta, assignables::qualifications::Qualification, user::User},
+};
 
-#[derive(Debug, Default, Clone)]
-pub struct QualificationRecord {
+#[derive(Debug, Default, Clone, FromRow)]
+pub struct QualificationRecord<'a> {
     pub id: i64,
-    pub user_id: i64,
-    pub qualification_id: i64,
-    pub author_id: i64,
+    pub user_id: ForeignKey<'a, User>,
+    pub author_id: ForeignKey<'a, User>,
+    pub qualification_id: ForeignKey<'a, Qualification>,
     pub created_at: i64,
 }
 
-impl QualificationRecord {
+impl<'a> TableMeta<'a> for QualificationRecord<'a> {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "records_qualifications";
+}
+
+impl<'a> QualificationRecord<'a> {
     pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
         let session = sqlx::query_as!(
             QualificationRecord,
@@ -20,9 +29,9 @@ impl QualificationRecord {
                 VALUES ($1, $2, $3, $4)
                 RETURNING *
             "#,
-            self.user_id,
-            self.qualification_id,
-            self.author_id,
+            *self.user_id,
+            *self.qualification_id,
+            *self.author_id,
             self.created_at,
         )
         .fetch_one(pool)

src/db/tables/records/ranks.rs

@@ -1,17 +1,26 @@
 use anyhow::Result;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
+use crate::db::{
+    CurrPool,
+    tables::{ForeignKey, TableMeta, assignables::ranks::Rank, user::User},
+};
 
-#[derive(Debug, Default, Clone)]
-pub struct RankRecord {
+#[derive(Debug, Default, Clone, FromRow)]
+pub struct RankRecord<'a> {
     pub id: i64,
-    pub user_id: i64,
-    pub rank_id: i64,
-    pub author_id: i64,
+    pub user_id: ForeignKey<'a, User>,
+    pub rank_id: ForeignKey<'a, Rank>,
+    pub author_id: ForeignKey<'a, User>,
     pub created_at: i64,
 }
 
-impl RankRecord {
+impl<'a> TableMeta<'a> for RankRecord<'a> {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "records_ranks";
+}
+
+impl<'a> RankRecord<'a> {
     pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
         let session = sqlx::query_as!(
             RankRecord,
@@ -20,9 +29,9 @@ impl RankRecord {
                 VALUES ($1, $2, $3, $4)
                 RETURNING *
             "#,
-            self.user_id,
-            self.rank_id,
-            self.author_id,
+            *self.user_id,
+            *self.rank_id,
+            *self.author_id,
             self.created_at,
         )
         .fetch_one(pool)

src/db/tables/records/trainings.rs

@@ -1,17 +1,26 @@
 use anyhow::Result;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
+use crate::db::{
+    CurrPool,
+    tables::{ForeignKey, TableMeta, assignables::trainings::Training, user::User},
+};
 
-#[derive(Debug, Default, Clone)]
-pub struct TrainingRecord {
+#[derive(Debug, Default, Clone, FromRow)]
+pub struct TrainingRecord<'a> {
     pub id: i64,
-    pub user_id: i64,
-    pub training_id: i64,
-    pub author_id: i64,
+    pub user_id: ForeignKey<'a, User>,
+    pub training_id: ForeignKey<'a, Training>,
+    pub author_id: ForeignKey<'a, User>,
     pub created_at: i64,
 }
 
-impl TrainingRecord {
+impl<'a> TableMeta<'a> for TrainingRecord<'a> {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "records_trainings";
+}
+
+impl<'a> TrainingRecord<'a> {
     pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
         let session = sqlx::query_as!(
             TrainingRecord,
@@ -20,9 +29,9 @@ impl TrainingRecord {
                 VALUES ($1, $2, $3, $4)
                 RETURNING *
             "#,
-            self.user_id,
-            self.training_id,
-            self.author_id,
+            *self.user_id,
+            *self.training_id,
+            *self.author_id,
             self.created_at,
         )
         .fetch_one(pool)

src/db/tables/sessions.rs

@@ -1,14 +1,20 @@
 use anyhow::Result;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
+use crate::db::{CurrPool, tables::TableMeta};
 
-#[derive(Debug, Default, Clone)]
+#[derive(Debug, Default, Clone, FromRow)]
 pub struct Session {
     pub user_id: i64,
     pub session_key: String,
     pub expires: i64,
 }
 
+impl TableMeta<'_> for Session {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "sessions";
+}
+
 impl Session {
     pub async fn insert_new(&self, pool: &CurrPool) -> Result<Self> {
         let session = sqlx::query_as!(

src/db/tables/user.rs

@@ -1,8 +1,8 @@
 use anyhow::bail;
+use sqlx::prelude::FromRow;
 
-use crate::db::CurrPool;
-
-#[derive(Debug, Default, Clone)]
+use crate::db::{CurrPool, tables::TableMeta};
+#[derive(Debug, Default, Clone, FromRow)]
 pub struct User {
     pub id: i64,
     pub email: String,
@@ -11,6 +11,12 @@ pub struct User {
     pub pw_hash: String,
     pub pw_salt: String,
     pub pfp_id: i64,
+    pub rank_id: i64,
+}
+
+impl TableMeta<'_> for User {
+    type PrimaryKey = i64;
+    const TABLE: &'static str = "users";
 }
 
 impl User {