stefiosif/loft
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat(backend): add opendal storage for file payload and postgres record for metadata, add CORS layer

Browse Source
This commit is contained in:
stefiosif
2026-05-21 00:26:28 +03:00
parent 0aa87d61e5
commit ce835da9a4
7 changed files with 1098 additions and 87 deletions
Download Patch File Download Diff File Expand all files Collapse all files

890
backend/Cargo.lock generated
View File

File diff suppressed because it is too large Load Diff

7
backend/Cargo.toml
View File

@@ -5,11 +5,11 @@ edition = "2024"
[dependencies]
anyhow = "1.0.102"
axum = { version = "0.8.9", features = ["tracing"] }
axum = { version = "0.8.9", features = ["tracing", "multipart", "macros"] }
serde = { version = "1.0.228", features = ["derive"] }
serde_json = "1.0.149"
tokio = { version = "1.52.1", features = ["full"] }
tower-http = { version = "0.6.8", features = ["fs", "trace"] }
tokio = { version = "1.52.3", features = ["full"] }
tower-http = { version = "0.6.10", features = ["fs", "trace", "cors"] }
tower-cookies = "0.11.0"
tracing = "0.1.44"
tracing-subscriber = { version = "0.3.23", features = ["env-filter"] }
@@ -17,6 +17,7 @@ lazy-regex = "3.6.0"
sqlx = { version = "0.8", features = ["runtime-tokio-rustls", "postgres", "uuid", "chrono"] }
chrono = { version = "0.4.44", features = ["serde"] }
dotenvy = "0.15.7"
opendal = { version = "0.56.0", features = ["tests", "services-fs"] }
[dev-dependencies]
axum-test = "20.0.0"

1
backend/migrations/20260511201435_add_storage_path_to_file_records.sql Normal file
View File

@@ -0,0 +1 @@
ALTER TABLE file_records ADD COLUMN storage_path TEXT NOT NULL DEFAULT '';

5
backend/src/error.rs
View File

@@ -10,6 +10,7 @@ pub enum LoftError {
AuthFailTokenWrongFormat,
AuthFailCtxNotInRequestExt,
FileIdNotFound,
UndefinedErrorType,
}
impl fmt::Display for LoftError {
@@ -34,6 +35,10 @@ impl IntoResponse for LoftError {
info!("NOT_FOUND");
StatusCode::NOT_FOUND.into_response()
}
Self::UndefinedErrorType => {
info!("INTERNAL_SERVER_ERROR");
StatusCode::INTERNAL_SERVER_ERROR.into_response()
}
}
}
}

22
backend/src/main.rs
View File

@@ -4,9 +4,15 @@ mod model;
mod web;
use anyhow::Result;
use axum::{Router, middleware, response::Response};
use axum::{
Router,
extract::DefaultBodyLimit,
http::{HeaderValue, Method, header},
middleware,
response::Response,
};
use tower_cookies::CookieManagerLayer;
use tower_http::{services::ServeDir, trace::TraceLayer};
use tower_http::{cors::CorsLayer, services::ServeDir, trace::TraceLayer};
use tracing::info;
use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt};
@@ -33,8 +39,9 @@ async fn main() -> Result<()> {
let file_repository = FileRepository::new().await?;
let routes_file =
routes_file(file_repository.clone()).route_layer(middleware::from_fn(mw_require_auth));
let routes_file = routes_file(file_repository.clone())
.route_layer(middleware::from_fn(mw_require_auth))
.layer(DefaultBodyLimit::disable());
let app = Router::new()
.nest("/api", routes_file)
@@ -47,6 +54,13 @@ async fn main() -> Result<()> {
mw_ctx_resolver,
))
.layer(CookieManagerLayer::new())
.layer(
CorsLayer::new()
.allow_origin("http://localhost:5173".parse::<HeaderValue>().unwrap())
.allow_methods([Method::GET, Method::POST, Method::DELETE])
.allow_credentials(true)
.allow_headers([header::CONTENT_TYPE]),
)
.fallback_service(ServeDir::new("./"));
let listener = tokio::net::TcpListener::bind("0.0.0.0:3000").await?;

140
backend/src/model.rs
View File

@@ -1,26 +1,24 @@
use opendal::{Operator, layers::LoggingLayer, services};
use serde::{Deserialize, Serialize};
use sqlx::{PgPool, prelude::FromRow};
use sqlx::{PgPool, prelude::FromRow, types::uuid};
use std::fmt::Display;
use tracing::info;
use crate::error::LoftError;
#[derive(Clone, Debug, Serialize, FromRow)]
#[serde(rename_all = "camelCase")]
pub struct FileRecord {
pub id: i64,
// pub user_id: i64,
pub name: String,
pub file_type: String,
pub size: i64,
#[serde(skip_serializing)]
pub storage_path: String,
pub uploaded_at: chrono::DateTime<chrono::Utc>,
}
#[derive(Clone, Debug, Deserialize)]
pub struct FileToCreate {
pub name: String,
pub file_type: FileType,
pub size: i64,
}
#[derive(Clone, Debug, Serialize, Deserialize)]
pub enum FileType {
Image,
@@ -41,6 +39,7 @@ impl Display for FileType {
#[derive(Clone)]
pub struct FileRepository {
pub pool: PgPool,
pub op: Operator,
}
impl FileRepository {
@@ -49,20 +48,39 @@ impl FileRepository {
let database_url = std::env::var("DATABASE_URL").expect("DATABASE_URL must be set");
let pool = PgPool::connect(&database_url).await.unwrap();
Ok(Self { pool })
let storage_path = std::env::var("STORAGE_PATH").expect("STORAGE_PATH must be set");
let op = Operator::new(services::Fs::default().root(&storage_path))
.unwrap()
.layer(LoggingLayer::default())
.finish();
//.map_err(|x| LoftError::customerror)?;
Ok(Self { pool, op })
}
pub async fn upload_file(&self, file_to_create: FileToCreate) -> Result<FileRecord, LoftError> {
pub async fn upload_file(
&self,
bytes: Vec<u8>,
file_name: String,
) -> Result<FileRecord, LoftError> {
let storage_path_name = format!("{}-{}", file_name, uuid::Uuid::new_v4());
let bytes_length = bytes.len();
info!("Uploading file \"{}\"", file_name);
self.op.write(&storage_path_name, bytes).await.unwrap();
info!("Saving metadata of file \"{}\" in file_records", file_name);
let file = sqlx::query_as!(
FileRecord,
r#"
INSERT INTO file_records (name, file_type, size)
VALUES ($1, $2, $3)
INSERT INTO file_records (name, file_type, size, storage_path)
VALUES ($1, $2, $3, $4)
RETURNING *
"#,
file_to_create.name,
file_to_create.file_type.to_string(),
file_to_create.size as i64
file_name,
"TODO-file_type".to_string(),
bytes_length as i64,
storage_path_name
)
.fetch_one(&self.pool)
.await
@@ -71,8 +89,24 @@ impl FileRepository {
Ok(file)
}
pub async fn download_file(&self, file_id: i64) -> Result<FileRecord, LoftError> {
sqlx::query_as!(
pub async fn download_file(&self, file_id: i64) -> Result<Vec<u8>, LoftError> {
info!(
"Fetching metadata of file \"{}\" from file_records",
file_id
);
let record = self.get_file(file_id).await?;
info!("Downloading file \"{}\"", file_id);
let bytes = self.op.read(&record.storage_path).await.unwrap();
Ok(bytes.to_vec())
}
pub async fn get_file(&self, file_id: i64) -> Result<FileRecord, LoftError> {
info!(
"Fetching metadata of file \"{}\" from file_records",
file_id
);
let record = sqlx::query_as!(
FileRecord,
r#"
SELECT *
@@ -84,10 +118,21 @@ impl FileRepository {
.fetch_optional(&self.pool)
.await
.unwrap()
.ok_or(LoftError::FileIdNotFound)
.ok_or(LoftError::FileIdNotFound)?;
Ok(record)
}
pub async fn delete_file(&self, file_id: i64) -> Result<FileRecord, LoftError> {
info!(
"Fetching metadata of file \"{}\" from file_records",
file_id
);
let record = self.get_file(file_id).await?;
info!("Downloading file bytes \"{}\"", file_id);
self.op.delete(&record.storage_path).await.unwrap();
info!("Downloading file record \"{}\"", file_id);
sqlx::query_as!(
FileRecord,
r#"
@@ -123,57 +168,61 @@ impl FileRepository {
mod tests {
use super::*;
async fn file_repository() -> Result<FileRepository, LoftError> {
Ok(FileRepository::new().await.unwrap())
async fn truncate(pool: &PgPool) {
sqlx::query!("TRUNCATE TABLE file_records")
.execute(pool)
.await
.unwrap();
}
fn new_file_record(name: &str, file_type: FileType, size: i64) -> FileToCreate {
FileToCreate {
name: name.to_string(),
file_type,
size,
}
async fn file_repository() -> Result<FileRepository, LoftError> {
Ok(FileRepository::new().await.unwrap())
}
#[tokio::test]
#[serial_test::serial]
async fn test_upload_and_list() {
let file_repository = file_repository().await.unwrap();
sqlx::query!("TRUNCATE TABLE file_records")
.execute(&file_repository.pool)
truncate(&file_repository.pool).await;
file_repository
.upload_file(vec![0u8; 10], "a.jpg".to_string())
.await
.unwrap();
file_repository
.upload_file(vec![0u8; 10], "b.jpg".to_string())
.await
.unwrap();
let file_a = new_file_record("a", FileType::Document, 10);
let file_b = new_file_record("b", FileType::Document, 10);
file_repository.upload_file(file_a).await.unwrap();
file_repository.upload_file(file_b).await.unwrap();
let files = file_repository.list_files().await.unwrap();
assert_eq!(files.len(), 2);
truncate(&file_repository.pool).await;
}
#[tokio::test]
#[serial_test::serial]
async fn test_download() {
let file_repository = file_repository().await.unwrap();
sqlx::query!("TRUNCATE TABLE file_records")
.execute(&file_repository.pool)
truncate(&file_repository.pool).await;
let uploaded = file_repository
.upload_file(vec![0u8; 10], "a.jpg".to_string())
.await
.unwrap();
let file_a = new_file_record("a", FileType::Document, 10);
let uploaded = file_repository.upload_file(file_a).await.unwrap();
let downloaded = file_repository.download_file(uploaded.id).await.unwrap();
assert_eq!(downloaded.name, "a");
assert!(!downloaded.is_empty());
truncate(&file_repository.pool).await;
}
#[tokio::test]
#[serial_test::serial]
async fn test_download_not_found() {
let file_repository = file_repository().await.unwrap();
truncate(&file_repository.pool).await;
assert!(matches!(
file_repository.download_file(99).await,
file_repository.download_file(i64::MAX).await,
Err(LoftError::FileIdNotFound)
));
}
@@ -182,18 +231,19 @@ mod tests {
#[serial_test::serial]
async fn test_delete() {
let file_repository = file_repository().await.unwrap();
sqlx::query!("TRUNCATE TABLE file_records")
.execute(&file_repository.pool)
truncate(&file_repository.pool).await;
let uploaded = file_repository
.upload_file(vec![0u8; 10], "a.jpg".to_string())
.await
.unwrap();
let file_a = new_file_record("a", FileType::Document, 10);
let uploaded = file_repository.upload_file(file_a).await.unwrap();
file_repository.delete_file(uploaded.id).await.unwrap();
assert!(matches!(
file_repository.download_file(uploaded.id).await,
Err(LoftError::FileIdNotFound)
));
truncate(&file_repository.pool).await;
}
#[tokio::test]

120
backend/src/web/routes_file.rs
View File

@@ -1,40 +1,69 @@
use axum::{
Json, Router,
extract::{Path, State},
extract::{Multipart, Path, State},
response::IntoResponse,
routing::get,
};
use tracing::info;
use crate::{
error::LoftError,
model::{FileRecord, FileRepository, FileToCreate},
model::{FileRecord, FileRepository},
};
pub fn routes_file(file_repository: FileRepository) -> Router {
Router::new()
.route("/files", get(list_files).post(upload_file))
.route("/files/{id}", get(download_file).delete(delete_file))
.route("/files/{id}", get(get_file).delete(delete_file))
.route("/files/{id}/download", get(download_file))
.with_state(file_repository)
}
async fn upload_file(
State(file_repository): State<FileRepository>,
Json(file_to_create): Json<FileToCreate>,
mut multipart: Multipart,
) -> Result<Json<FileRecord>, LoftError> {
info!("handler: upload_file");
let file = file_repository.upload_file(file_to_create).await?;
Ok(Json(file))
let mut file_name = None;
let mut file_type: Option<String> = None;
let mut bytes = None;
while let Some(field) = multipart.next_field().await.unwrap() {
match field.name().unwrap() {
// "file_type" => file_type = Some(field.text().await.unwrap().parse().unwrap()),
"file" => {
file_name = field.file_name().map(|s| s.to_string());
bytes = Some(field.bytes().await.unwrap().to_vec())
}
_ => (),
}
}
if let (Some(bytes), Some(file_name)) = (bytes, file_name) {
let file = file_repository.upload_file(bytes, file_name).await?;
return Ok(Json(file));
}
Err(LoftError::UndefinedErrorType)
}
async fn download_file(
#[axum::debug_handler]
async fn get_file(
State(file_repository): State<FileRepository>,
Path(file_id): Path<u64>,
) -> Result<Json<FileRecord>, LoftError> {
info!("handler: download_file");
let record = file_repository.get_file(file_id as i64).await?;
Ok(Json(record))
}
let file = file_repository.download_file(file_id as i64).await?;
Ok(Json(file))
#[axum::debug_handler]
async fn download_file(
State(file_repository): State<FileRepository>,
Path(file_id): Path<u64>,
) -> Result<impl IntoResponse, LoftError> {
let bytes = file_repository.download_file(file_id as i64).await?;
Ok(bytes)
}
async fn delete_file(
@@ -60,8 +89,12 @@ async fn list_files(
#[cfg(test)]
mod tests {
use axum::{Router, middleware};
use axum_test::TestServer;
use axum_test::{
TestServer,
multipart::{MultipartForm, Part},
};
use serde_json::json;
use sqlx::PgPool;
use tower_cookies::CookieManagerLayer;
use crate::{
@@ -90,6 +123,13 @@ mod tests {
TestServer::new(app)
}
async fn truncate(pool: &PgPool) {
sqlx::query!("TRUNCATE TABLE file_records")
.execute(pool)
.await
.unwrap();
}
#[tokio::test]
async fn test_requires_auth() {
let server = test_server().await;
@@ -107,23 +147,28 @@ mod tests {
}
#[tokio::test]
#[serial_test::serial]
async fn test_requires_auth_post() {
let file_repository = FileRepository::new().await.unwrap();
truncate(&file_repository.pool).await;
let server = test_server().await;
server
.post("/api/files")
.json(&json!({"name": "a", "file_type": "Document"}))
.multipart(MultipartForm::new().add_part(
"file",
Part::bytes(b"fake_bytes".to_vec()).file_name("a.jpg"),
))
.await
.assert_status_unauthorized();
truncate(&file_repository.pool).await;
}
#[tokio::test]
#[serial_test::serial]
async fn test_list_files_empty() {
let file_repository = FileRepository::new().await.unwrap();
sqlx::query!("TRUNCATE TABLE file_records")
.execute(&file_repository.pool)
.await
.unwrap();
truncate(&file_repository.pool).await;
let server = test_server().await;
server
@@ -138,47 +183,56 @@ mod tests {
#[serial_test::serial]
async fn test_upload_and_list_files() {
let file_repository = FileRepository::new().await.unwrap();
sqlx::query!("TRUNCATE TABLE file_records")
.execute(&file_repository.pool)
.await
.unwrap();
truncate(&file_repository.pool).await;
let server = test_server().await;
let res = server
.post("/api/files")
.add_header(axum::http::header::COOKIE, AUTH_COOKIE)
.json(&json!({"name": "a", "file_type": "Document", "size": 10}))
.multipart(MultipartForm::new().add_part(
"file",
Part::bytes(b"fake_bytes".to_vec()).file_name("a.jpg"),
))
.await;
res.assert_status_ok();
let file = res.json::<serde_json::Value>();
assert_eq!(file["name"], "a");
assert_eq!(file["file_type"], "Document");
assert_eq!(file["size"], 10);
assert_eq!(file["name"], "a.jpg");
let list = server
.get("/api/files")
.add_header(axum::http::header::COOKIE, AUTH_COOKIE)
.await
.json::<serde_json::Value>();
assert_eq!(list.as_array().unwrap().len(), 1);
truncate(&file_repository.pool).await;
}
#[tokio::test]
#[serial_test::serial]
async fn test_download_file() {
let file_repository = FileRepository::new().await.unwrap();
truncate(&file_repository.pool).await;
let server = test_server().await;
let post_res = server
.post("/api/files")
.add_header(axum::http::header::COOKIE, AUTH_COOKIE)
.json(&json!({"name": "b", "file_type": "Document", "size": 10}))
.multipart(MultipartForm::new().add_part(
"file",
Part::bytes(b"fake_bytes".to_vec()).file_name("a.jpg"),
))
.await;
let id = post_res.json::<serde_json::Value>()["id"].as_i64().unwrap();
let res = server
.get(&format!("/api/files/{id}"))
.get(&format!("/api/files/{id}/download"))
.add_header(axum::http::header::COOKIE, AUTH_COOKIE)
.await;
res.assert_status_ok();
assert_eq!(res.json::<serde_json::Value>()["name"], "b");
assert_eq!(res.as_bytes(), b"fake_bytes".as_ref());
truncate(&file_repository.pool).await;
}
#[tokio::test]
@@ -186,7 +240,7 @@ mod tests {
async fn test_download_file_not_found() {
let server = test_server().await;
server
.get("/api/files/99")
.get("/api/files/99/download")
.add_header(axum::http::header::COOKIE, AUTH_COOKIE)
.await
.assert_status_not_found();
@@ -195,11 +249,17 @@ mod tests {
#[tokio::test]
#[serial_test::serial]
async fn test_delete_file() {
let file_repository = FileRepository::new().await.unwrap();
truncate(&file_repository.pool).await;
let server = test_server().await;
let post_res = server
.post("/api/files")
.add_header(axum::http::header::COOKIE, AUTH_COOKIE)
.json(&json!({"name": "c", "file_type": "Document", "size": 10}))
.multipart(MultipartForm::new().add_part(
"file",
Part::bytes(b"fake_bytes".to_vec()).file_name("a.jpg"),
))
.await;
let id = post_res.json::<serde_json::Value>()["id"].as_i64().unwrap();
@@ -214,6 +274,8 @@ mod tests {
.add_header(axum::http::header::COOKIE, AUTH_COOKIE)
.await
.assert_status_not_found();
truncate(&file_repository.pool).await;
}
#[tokio::test]