Switch to Postgres (#39)

* WIP Switch to Postgres

* feat(postgres): more work on porting to postgres, now compiles

* feat(docker-compose): Changed the docker-compose.yml file to use postgres.

* Update docker, documentation, gh actions...

* Remove bson dependency

* Remove bson import

* feat: move mock filehost to trait rather than cargo feature

* feat(postgres): transactions for mod creation, multipart refactor

* fix: Add Cargo.lock so that sqlx functions

* Update sqlx offline build data

* fix: Use SQLX_OFFLINE to force sqlx into offline mode for CI

* Default release channels

* feat(postgres): refactor database models to fit postgres models

* fix: Fix sqlx prepare, fix double allocation in indexing

* Add dockerfile (#40)

Co-authored-by: Charalampos Fanoulis <charalampos.fanoulis@gmail.com>

Co-authored-by: Aeledfyr <aeledfyr@gmail.com>
Co-authored-by: redblueflame <contact@redblueflame.com>
Co-authored-by: Jai A <jai.a@tuta.io>
Co-authored-by: Valentin Ricard <redblueflame1@gmail.Com>
Co-authored-by: Charalampos Fanoulis <charalampos.fanoulis@gmail.com>

src/database/models/ids.rs

@@ -0,0 +1,141 @@
+use super::DatabaseError;
+use crate::models::ids::random_base62;
+use sqlx_macros::Type;
+
+const ID_RETRY_COUNT: usize = 20;
+
+macro_rules! generate_ids {
+    ($vis:vis $function_name:ident, $return_type:ty, $id_length:expr, $select_stmnt:literal, $id_function:expr) => {
+        $vis async fn $function_name(
+            con: &mut sqlx::Transaction<'_, sqlx::Postgres>,
+        ) -> Result<$return_type, DatabaseError> {
+            let length = $id_length;
+            let mut id = random_base62(length);
+            let mut retry_count = 0;
+
+            // Check if ID is unique
+            loop {
+                let results = sqlx::query!($select_stmnt, id as i64)
+                    .fetch_one(&mut *con)
+                    .await?;
+
+                if results.exists.unwrap_or(true) {
+                    id = random_base62(length);
+                } else {
+                    break;
+                }
+
+                retry_count += 1;
+                if retry_count > ID_RETRY_COUNT {
+                    return Err(DatabaseError::RandomIdError);
+                }
+            }
+
+            Ok($id_function(id as i64))
+        }
+    };
+}
+
+generate_ids!(
+    pub generate_mod_id,
+    ModId,
+    8,
+    "SELECT EXISTS(SELECT 1 FROM mods WHERE id=$1)",
+    ModId
+);
+generate_ids!(
+    pub generate_version_id,
+    VersionId,
+    8,
+    "SELECT EXISTS(SELECT 1 FROM versions WHERE id=$1)",
+    VersionId
+);
+generate_ids!(
+    pub generate_team_id,
+    TeamId,
+    8,
+    "SELECT EXISTS(SELECT 1 FROM teams WHERE id=$1)",
+    TeamId
+);
+generate_ids!(
+    pub generate_file_id,
+    FileId,
+    8,
+    "SELECT EXISTS(SELECT 1 FROM files WHERE id=$1)",
+    FileId
+);
+generate_ids!(
+    pub generate_team_member_id,
+    TeamMemberId,
+    8,
+    "SELECT EXISTS(SELECT 1 FROM team_members WHERE id=$1)",
+    TeamMemberId
+);
+
+#[derive(Copy, Clone, Debug, Type)]
+pub struct UserId(pub i64);
+
+#[derive(Copy, Clone, Debug, Type)]
+pub struct TeamId(pub i64);
+#[derive(Copy, Clone, Debug, Type)]
+pub struct TeamMemberId(pub i64);
+
+#[derive(Copy, Clone, Debug, Type)]
+pub struct ModId(pub i64);
+
+#[derive(Copy, Clone, Debug, Type)]
+pub struct VersionId(pub i64);
+#[derive(Copy, Clone, Debug, Type)]
+pub struct ChannelId(pub i64);
+#[derive(Copy, Clone, Debug, Type)]
+pub struct GameVersionId(pub i32);
+#[derive(Copy, Clone, Debug, Type)]
+pub struct LoaderId(pub i32);
+#[derive(Copy, Clone, Debug, Type)]
+pub struct CategoryId(pub i32);
+
+#[derive(Copy, Clone, Debug, Type)]
+pub struct FileId(pub i64);
+
+use crate::models::ids;
+
+impl From<ids::ModId> for ModId {
+    fn from(id: ids::ModId) -> Self {
+        ModId(id.0 as i64)
+    }
+}
+impl From<ModId> for ids::ModId {
+    fn from(id: ModId) -> Self {
+        ids::ModId(id.0 as u64)
+    }
+}
+impl From<ids::UserId> for UserId {
+    fn from(id: ids::UserId) -> Self {
+        UserId(id.0 as i64)
+    }
+}
+impl From<UserId> for ids::UserId {
+    fn from(id: UserId) -> Self {
+        ids::UserId(id.0 as u64)
+    }
+}
+impl From<ids::TeamId> for TeamId {
+    fn from(id: ids::TeamId) -> Self {
+        TeamId(id.0 as i64)
+    }
+}
+impl From<TeamId> for ids::TeamId {
+    fn from(id: TeamId) -> Self {
+        ids::TeamId(id.0 as u64)
+    }
+}
+impl From<ids::VersionId> for VersionId {
+    fn from(id: ids::VersionId) -> Self {
+        VersionId(id.0 as i64)
+    }
+}
+impl From<VersionId> for ids::VersionId {
+    fn from(id: VersionId) -> Self {
+        ids::VersionId(id.0 as u64)
+    }
+}