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/file_hosting/backblaze/authorization.rs

@@ -0,0 +1,79 @@
+use crate::file_hosting::FileHostingError;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct AuthorizationPermissions {
+    bucket_id: Option<String>,
+    bucket_name: Option<String>,
+    capabilities: Vec<String>,
+    name_prefix: Option<String>,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct AuthorizationData {
+    pub absolute_minimum_part_size: i32,
+    pub account_id: String,
+    pub allowed: AuthorizationPermissions,
+    pub api_url: String,
+    pub authorization_token: String,
+    pub download_url: String,
+    pub recommended_part_size: i32,
+}
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct UploadUrlData {
+    pub bucket_id: String,
+    pub upload_url: String,
+    pub authorization_token: String,
+}
+
+pub async fn authorize_account(
+    key_id: &str,
+    application_key: &str,
+) -> Result<AuthorizationData, FileHostingError> {
+    let combined_key = format!("{}:{}", key_id, application_key);
+    let formatted_key = format!("Basic {}", base64::encode(combined_key));
+
+    let response = reqwest::Client::new()
+        .get("https://api.backblazeb2.com/b2api/v2/b2_authorize_account")
+        .header(reqwest::header::CONTENT_TYPE, "application/json")
+        .header(reqwest::header::AUTHORIZATION, formatted_key)
+        .send()
+        .await?;
+
+    if response.status().is_success() {
+        Ok(response.json().await?)
+    } else {
+        Err(FileHostingError::BackblazeError(response.json().await?))
+    }
+}
+
+pub async fn get_upload_url(
+    authorization_data: &AuthorizationData,
+    bucket_id: &str,
+) -> Result<UploadUrlData, FileHostingError> {
+    let response = reqwest::Client::new()
+        .post(&format!("{}/b2api/v2/b2_get_upload_url", authorization_data.api_url).to_string())
+        .header(reqwest::header::CONTENT_TYPE, "application/json")
+        .header(
+            reqwest::header::AUTHORIZATION,
+            &authorization_data.authorization_token,
+        )
+        .body(
+            serde_json::json!({
+                "bucketId": bucket_id,
+            })
+            .to_string(),
+        )
+        .send()
+        .await?;
+
+    if response.status().is_success() {
+        Ok(response.json().await?)
+    } else {
+        Err(FileHostingError::BackblazeError(response.json().await?))
+    }
+}

src/file_hosting/backblaze/delete.rs

@@ -0,0 +1,42 @@
+use super::authorization::AuthorizationData;
+use crate::file_hosting::FileHostingError;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct DeleteFileData {
+    pub file_id: String,
+    pub file_name: String,
+}
+
+pub async fn delete_file_version(
+    authorization_data: &AuthorizationData,
+    file_id: &str,
+    file_name: &str,
+) -> Result<DeleteFileData, FileHostingError> {
+    let response = reqwest::Client::new()
+        .post(&format!(
+            "{}/b2api/v2/b2_delete_file_version",
+            authorization_data.api_url
+        ))
+        .header(reqwest::header::CONTENT_TYPE, "application/json")
+        .header(
+            reqwest::header::AUTHORIZATION,
+            &authorization_data.authorization_token,
+        )
+        .body(
+            serde_json::json!({
+                "fileName": file_name,
+                "fileId": file_id
+            })
+            .to_string(),
+        )
+        .send()
+        .await?;
+
+    if response.status().is_success() {
+        Ok(response.json().await?)
+    } else {
+        Err(FileHostingError::BackblazeError(response.json().await?))
+    }
+}

src/file_hosting/backblaze/upload.rs

@@ -0,0 +1,48 @@
+use super::authorization::UploadUrlData;
+use crate::file_hosting::FileHostingError;
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Clone)]
+#[serde(rename_all = "camelCase")]
+pub struct UploadFileData {
+    pub file_id: String,
+    pub file_name: String,
+    pub account_id: String,
+    pub bucket_id: String,
+    pub content_length: u32,
+    pub content_sha1: String,
+    pub content_md5: Option<String>,
+    pub content_type: String,
+    pub upload_timestamp: u64,
+}
+
+//Content Types found here: https://www.backblaze.com/b2/docs/content-types.html
+pub async fn upload_file(
+    url_data: &UploadUrlData,
+    content_type: &str,
+    file_name: &str,
+    file_bytes: Vec<u8>,
+) -> Result<UploadFileData, FileHostingError> {
+    let response = reqwest::Client::new()
+        .post(&url_data.upload_url)
+        .header(
+            reqwest::header::AUTHORIZATION,
+            &url_data.authorization_token,
+        )
+        .header("X-Bz-File-Name", file_name)
+        .header(reqwest::header::CONTENT_TYPE, content_type)
+        .header(reqwest::header::CONTENT_LENGTH, file_bytes.len())
+        .header(
+            "X-Bz-Content-Sha1",
+            sha1::Sha1::from(&file_bytes).hexdigest(),
+        )
+        .body(file_bytes)
+        .send()
+        .await?;
+
+    if response.status().is_success() {
+        Ok(response.json().await?)
+    } else {
+        Err(FileHostingError::BackblazeError(response.json().await?))
+    }
+}