GKaszewski/thoughts
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: add user profile management with update and retrieval endpoints, enhance database setup for testing

Browse Source
This commit is contained in:
Gabriel Kaszewski
2025-09-06 14:24:27 +02:00
parent 6e63dca513
commit c9e99e6f23
21 changed files with 422 additions and 42 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
compose.yml
View File

@@ -50,6 +50,21 @@ services:
- frontend
- backend
db_test:
image: postgres:15-alpine
container_name: thoughts-db-test
environment:
POSTGRES_USER: postgres
POSTGRES_PASSWORD: postgres
POSTGRES_DB: postgres
ports:
- "5434:5432"
healthcheck:
test: ["CMD-SHELL", "pg_isready -U postgres -d postgres"]
interval: 10s
timeout: 5s
retries: 5
volumes:
postgres_data:
driver: local

6
thoughts-backend/Cargo.lock generated
View File

@@ -4867,7 +4867,9 @@ dependencies = [
"axum 0.8.4",
"migration",
"sea-orm",
"tokio",
"tower 0.5.2",
"uuid",
]
[[package]]
@@ -4932,9 +4934,9 @@ checksum = "e2eebbbfe4093922c2b6734d7c679ebfebd704a0d7e56dfcb0d05818ce28977d"
[[package]]
name = "uuid"
version = "1.18.0"
version = "1.18.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "f33196643e165781c20a5ead5582283a7dacbb87855d867fbc2df3f81eddc1be"
checksum = "2f87b8aa10b915a06587d0dec516c282ff295b475d94abf425d62b57710070a2"
dependencies = [
"getrandom 0.3.3",
"js-sys",

3
thoughts-backend/Cargo.toml
View File

@@ -24,6 +24,7 @@ tracing = "0.1.41"
utoipa = { version = "5.4.0", features = ["macros", "chrono"] }
validator = { version = "0.20.0", default-features = false }
chrono = { version = "0.4.41", features = ["serde"] }
tokio = { version = "1.45.1", features = ["full"] }
[dependencies]
api = { path = "api" }
@@ -38,8 +39,8 @@ tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
# runtime
axum = { workspace = true, features = ["tokio", "http1", "http2"] }
tokio = { version = "1.45.1", features = ["full"] }
prefork = { version = "0.6.0", default-features = false, optional = true }
tokio = { version = "1.45.1", features = ["full"] }
# shuttle runtime
shuttle-axum = { version = "0.55.0", optional = true }

2
thoughts-backend/api/Cargo.toml
View File

@@ -18,7 +18,6 @@ bcrypt = "0.17.1"
jsonwebtoken = "9.3.1"
once_cell = "1.21.3"
tokio = "1.45.1"
# db
sea-orm = { workspace = true }
@@ -27,6 +26,7 @@ sea-orm = { workspace = true }
utoipa = { workspace = true }
serde_json = { workspace = true }
tokio = { workspace = true }
# local dependencies
app = { path = "../app" }

2
thoughts-backend/api/src/federation.rs
View File

@@ -21,7 +21,7 @@ pub async fn federate_thought(
};
if follower_ids.is_empty() {
tracing::debug!("No followers to federate to for user {}", author.username);
println!("No followers to federate to for user {}", author.username);
return;
}

49
thoughts-backend/api/src/routers/user.rs
View File

@@ -10,15 +10,15 @@ use serde_json::{json, Value};
use app::persistence::{
follow,
thought::get_thoughts_by_user,
user::{get_user, search_users},
user::{get_user, search_users, update_user_profile},
};
use app::state::AppState;
use app::{error::UserError, persistence::user::get_user_by_username};
use models::schemas::thought::ThoughtListSchema;
use models::schemas::user::{UserListSchema, UserSchema};
use models::{params::user::UpdateUserParams, schemas::thought::ThoughtListSchema};
use models::{queries::user::UserQuery, schemas::thought::ThoughtSchema};
use crate::extractor::Json;
use crate::extractor::{Json, Valid};
use crate::models::ApiErrorResponse;
use crate::{error::ApiError, extractor::AuthUser};
@@ -311,9 +311,52 @@ async fn user_outbox_get(
Ok((headers, Json(outbox)))
}
#[utoipa::path(
get,
path = "/me",
responses(
(status = 200, description = "Authenticated user's profile", body = UserSchema)
),
security(
("bearer_auth" = [])
)
)]
async fn get_me(
State(state): State<AppState>,
auth_user: AuthUser,
) -> Result<impl IntoResponse, ApiError> {
let user = get_user(&state.conn, auth_user.id)
.await?
.ok_or(UserError::NotFound)?;
Ok(axum::Json(UserSchema::from(user)))
}
#[utoipa::path(
put,
path = "/me",
request_body = UpdateUserParams,
responses(
(status = 200, description = "Profile updated", body = UserSchema),
(status = 400, description = "Bad request", body = ApiErrorResponse),
(status = 422, description = "Validation error", body = ApiErrorResponse)
),
security(
("bearer_auth" = [])
)
)]
async fn update_me(
State(state): State<AppState>,
auth_user: AuthUser,
Valid(Json(params)): Valid<Json<UpdateUserParams>>,
) -> Result<impl IntoResponse, ApiError> {
let updated_user = update_user_profile(&state.conn, auth_user.id, params).await?;
Ok(axum::Json(UserSchema::from(updated_user)))
}
pub fn create_user_router() -> Router<AppState> {
Router::new()
.route("/", get(users_get))
.route("/me", get(get_me).put(update_me))
.route("/{param}", get(get_user_by_param))
.route("/{username}/thoughts", get(user_thoughts_get))
.route(

3
thoughts-backend/app/Cargo.toml
View File

@@ -12,5 +12,4 @@ path = "src/lib.rs"
bcrypt = "0.17.1"
models = { path = "../models" }
validator = "0.20"
sea-orm = { workspace = true }
sea-orm = { version = "1.1.12" }

66
thoughts-backend/app/src/persistence/user.rs
View File

@@ -1,9 +1,13 @@
use sea_orm::{ActiveModelTrait, ColumnTrait, DbConn, DbErr, EntityTrait, QueryFilter, Set};
use sea_orm::{
ActiveModelTrait, ColumnTrait, DbConn, DbErr, EntityTrait, QueryFilter, Set, TransactionTrait,
};
use models::domains::user;
use models::params::user::CreateUserParams;
use models::params::user::{CreateUserParams, UpdateUserParams};
use models::queries::user::UserQuery;
use crate::error::UserError;
pub async fn create_user(
db: &DbConn,
params: CreateUserParams,
@@ -43,3 +47,61 @@ pub async fn get_users_by_ids(db: &DbConn, ids: Vec<i32>) -> Result<Vec<user::Mo
.all(db)
.await
}
pub async fn update_user_profile(
db: &DbConn,
user_id: i32,
params: UpdateUserParams,
) -> Result<user::Model, UserError> {
let mut user: user::ActiveModel = get_user(db, user_id)
.await
.map_err(|e| UserError::Internal(e.to_string()))?
.ok_or(UserError::NotFound)?
.into();
if let Some(display_name) = params.display_name {
user.display_name = Set(Some(display_name));
}
if let Some(bio) = params.bio {
user.bio = Set(Some(bio));
}
if let Some(avatar_url) = params.avatar_url {
user.avatar_url = Set(Some(avatar_url));
}
if let Some(header_url) = params.header_url {
user.header_url = Set(Some(header_url));
}
if let Some(custom_css) = params.custom_css {
user.custom_css = Set(Some(custom_css));
}
// This is a complex operation, so we use a transaction
if let Some(friend_usernames) = params.top_friends {
let txn = db
.begin()
.await
.map_err(|e| UserError::Internal(e.to_string()))?;
// 1. Delete old top friends
// In a real app, you would create a `top_friends` entity and use it here.
// For now, we'll skip this to avoid creating the model.
// 2. Find new friends by username
let _friends = user::Entity::find()
.filter(user::Column::Username.is_in(friend_usernames))
.all(&txn)
.await
.map_err(|e| UserError::Internal(e.to_string()))?;
// 3. Insert new friends
// This part would involve inserting into the `top_friends` table.
txn.commit()
.await
.map_err(|e| UserError::Internal(e.to_string()))?;
}
user.update(db)
.await
.map_err(|e| UserError::Internal(e.to_string()))
}

2
thoughts-backend/doc/src/user.rs
View File

@@ -18,6 +18,8 @@ use models::schemas::{
user_follow_delete,
user_inbox_post,
user_outbox_get,
get_me,
update_me
),
components(schemas(
CreateUserParams,

2
thoughts-backend/migration/src/lib.rs
View File

@@ -2,6 +2,7 @@ pub use sea_orm_migration::prelude::*;
mod m20240101_000001_init;
mod m20250905_000001_init;
mod m20250906_100000_add_profile_fields;
pub struct Migrator;
@@ -11,6 +12,7 @@ impl MigratorTrait for Migrator {
vec![
Box::new(m20240101_000001_init::Migration),
Box::new(m20250905_000001_init::Migration),
Box::new(m20250906_100000_add_profile_fields::Migration),
]
}
}

107
thoughts-backend/migration/src/m20250906_100000_add_profile_fields.rs Normal file
View File

@@ -0,0 +1,107 @@
use super::m20240101_000001_init::User;
use sea_orm_migration::{prelude::*, schema::*};
#[derive(DeriveMigrationName)]
pub struct Migration;
#[async_trait::async_trait]
impl MigrationTrait for Migration {
async fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.alter_table(
Table::alter()
.table(User::Table)
.add_column(string_null(UserExtension::Email).unique_key())
.add_column(string_null(UserExtension::DisplayName))
.add_column(string_null(UserExtension::Bio))
.add_column(text_null(UserExtension::AvatarUrl))
.add_column(text_null(UserExtension::HeaderUrl))
.add_column(text_null(UserExtension::CustomCss))
.add_column(
timestamp_with_time_zone(UserExtension::CreatedAt)
.not_null()
.default(Expr::current_timestamp()),
)
.add_column(
timestamp_with_time_zone(UserExtension::UpdatedAt)
.not_null()
.default(Expr::current_timestamp()),
)
.to_owned(),
)
.await?;
manager
.create_table(
Table::create()
.table(TopFriends::Table)
.if_not_exists()
.col(integer(TopFriends::UserId).not_null())
.col(integer(TopFriends::FriendId).not_null())
.col(small_integer(TopFriends::Position).not_null())
.primary_key(
Index::create()
.col(TopFriends::UserId)
.col(TopFriends::FriendId),
)
.foreign_key(
ForeignKey::create()
.name("fk_top_friends_user_id")
.from(TopFriends::Table, TopFriends::UserId)
.to(User::Table, User::Id)
.on_delete(ForeignKeyAction::Cascade),
)
.foreign_key(
ForeignKey::create()
.name("fk_top_friends_friend_id")
.from(TopFriends::Table, TopFriends::FriendId)
.to(User::Table, User::Id)
.on_delete(ForeignKeyAction::Cascade),
)
.to_owned(),
)
.await
}
async fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {
manager
.drop_table(Table::drop().table(TopFriends::Table).to_owned())
.await?;
manager
.alter_table(
Table::alter()
.table(User::Table)
.drop_column(UserExtension::Email)
.drop_column(UserExtension::DisplayName)
.drop_column(UserExtension::Bio)
.drop_column(UserExtension::AvatarUrl)
.drop_column(UserExtension::HeaderUrl)
.drop_column(UserExtension::CustomCss)
.drop_column(UserExtension::CreatedAt)
.drop_column(UserExtension::UpdatedAt)
.to_owned(),
)
.await
}
}
#[derive(DeriveIden)]
enum UserExtension {
Email,
DisplayName,
Bio,
AvatarUrl,
HeaderUrl,
CustomCss,
CreatedAt,
UpdatedAt,
}
#[derive(DeriveIden)]
enum TopFriends {
Table,
UserId,
FriendId,
Position,
}

9
thoughts-backend/models/src/domains/user.rs
View File

@@ -10,6 +10,15 @@ pub struct Model {
#[sea_orm(unique)]
pub username: String,
pub password_hash: Option<String>,
#[sea_orm(unique)]
pub email: Option<String>,
pub display_name: Option<String>,
pub bio: Option<String>,
pub avatar_url: Option<String>,
pub header_url: Option<String>,
pub custom_css: Option<String>,
pub created_at: DateTimeWithTimeZone,
pub updated_at: DateTimeWithTimeZone,
}
#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]

23
thoughts-backend/models/src/params/user.rs
View File

@@ -9,3 +9,26 @@ pub struct CreateUserParams {
#[validate(length(min = 6))]
pub password: String,
}
#[derive(Deserialize, Validate, ToSchema, Default)]
pub struct UpdateUserParams {
#[validate(length(max = 50))]
#[schema(example = "Frutiger Aero Fan")]
pub display_name: Option<String>,
#[validate(length(max = 160))]
#[schema(example = "Est. 2004")]
pub bio: Option<String>,
#[validate(url)]
pub avatar_url: Option<String>,
#[validate(url)]
pub header_url: Option<String>,
pub custom_css: Option<String>,
#[validate(length(max = 8))]
#[schema(example = json!(["username1", "username2"]))]
pub top_friends: Option<Vec<String>>,
}

16
thoughts-backend/models/src/schemas/user.rs
View File

@@ -1,3 +1,4 @@
use common::DateTimeWithTimeZoneWrapper;
use serde::Serialize;
use utoipa::ToSchema;
@@ -7,6 +8,15 @@ use crate::domains::user;
pub struct UserSchema {
pub id: i32,
pub username: String,
pub display_name: Option<String>,
pub bio: Option<String>,
pub avatar_url: Option<String>,
pub header_url: Option<String>,
pub custom_css: Option<String>,
// In a real implementation, you'd fetch and return this data.
// For now, we'll omit it from the schema to keep it simple.
// pub top_friends: Vec<String>,
pub joined_at: DateTimeWithTimeZoneWrapper,
}
impl From<user::Model> for UserSchema {
@@ -14,6 +24,12 @@ impl From<user::Model> for UserSchema {
Self {
id: user.id,
username: user.username,
display_name: user.display_name,
bio: user.bio,
avatar_url: user.avatar_url,
header_url: user.header_url,
custom_css: user.custom_css,
joined_at: user.created_at.into(),
}
}
}

2
thoughts-backend/src/tokio.rs
View File

@@ -48,7 +48,7 @@ pub fn run() {
let listener = std::net::TcpListener::bind(config.get_server_url()).expect("bind to port");
listener.set_nonblocking(true).expect("non blocking failed");
tracing::debug!("listening on http://{}", listener.local_addr().unwrap());
println!("listening on http://{}", listener.local_addr().unwrap());
#[cfg(feature = "prefork")]
if config.prefork {

16
thoughts-backend/tests/api/main.rs
View File

@@ -13,16 +13,24 @@ pub struct TestApp {
}
pub async fn setup() -> TestApp {
std::env::set_var("DATABASE_URL", "sqlite::memory:");
std::env::set_var(
"MANAGEMENT_DATABASE_URL",
"postgres://postgres:postgres@localhost:5434/postgres",
);
std::env::set_var(
"DATABASE_URL",
"postgres://postgres:postgres@localhost:5434/postgres",
);
std::env::set_var("AUTH_SECRET", "test_secret");
std::env::set_var("BASE_URL", "http://localhost:3000");
std::env::set_var("HOST", "localhost");
std::env::set_var("PORT", "3000");
std::env::set_var("LOG_LEVEL", "debug");
let db = setup_test_db("sqlite::memory:")
.await
.expect("Failed to set up test db");
let db = setup_test_db().await.expect("Failed to set up test db");
let db = db.clone();
let router = setup_router(db.clone(), &app::config::Config::from_env());
TestApp { router, db }
}

77
thoughts-backend/tests/api/user.rs
View File

@@ -1,10 +1,10 @@
use axum::http::StatusCode;
use http_body_util::BodyExt;
use serde_json::Value;
use serde_json::{json, Value};
use utils::testing::{make_get_request, make_post_request};
use utils::testing::{make_get_request, make_jwt_request, make_post_request};
use crate::api::main::setup;
use crate::api::main::{login_user, setup};
#[tokio::test]
async fn test_post_users() {
@@ -16,7 +16,11 @@ async fn test_post_users() {
assert_eq!(response.status(), StatusCode::CREATED);
let body = response.into_body().collect().await.unwrap().to_bytes();
assert_eq!(&body[..], br#"{"id":1,"username":"test"}"#);
let v: Value = serde_json::from_slice(&body).unwrap();
assert_eq!(v["id"], 1);
assert_eq!(v["username"], "test");
assert!(v["display_name"].is_null());
}
#[tokio::test]
@@ -26,7 +30,6 @@ pub(super) async fn test_post_users_error() {
let body = r#"{"username": "1", "password": "password123"}"#.to_owned();
let response = make_post_request(app.router, "/auth/register", body, None).await;
println!("{:?}", response);
assert_eq!(response.status(), StatusCode::UNPROCESSABLE_ENTITY);
let body = response.into_body().collect().await.unwrap().to_bytes();
@@ -46,5 +49,67 @@ pub async fn test_get_users() {
assert_eq!(response.status(), StatusCode::OK);
let body = response.into_body().collect().await.unwrap().to_bytes();
assert_eq!(&body[..], br#"{"users":[{"id":1,"username":"test"}]}"#);
let v: Value = serde_json::from_slice(&body).unwrap();
assert!(v["users"].is_array());
let users_array = v["users"].as_array().unwrap();
assert_eq!(users_array.len(), 1);
assert_eq!(users_array[0]["id"], 1);
assert_eq!(users_array[0]["username"], "test");
}
#[tokio::test]
async fn test_me_endpoints() {
let app = setup().await;
// 1. Register a new user
let register_body = json!({
"username": "me_user",
"password": "password123"
})
.to_string();
let response =
make_post_request(app.router.clone(), "/auth/register", register_body, None).await;
assert_eq!(response.status(), StatusCode::CREATED);
// 2. Log in to get a token
let token = login_user(app.router.clone(), "me_user", "password123").await;
// 3. GET /users/me to fetch initial profile
let response = make_jwt_request(app.router.clone(), "/users/me", "GET", None, &token).await;
assert_eq!(response.status(), StatusCode::OK);
let body = response.into_body().collect().await.unwrap().to_bytes();
let v: Value = serde_json::from_slice(&body).unwrap();
assert_eq!(v["username"], "me_user");
assert!(v["bio"].is_null());
assert!(v["display_name"].is_null());
// 4. PUT /users/me to update the profile
let update_body = json!({
"display_name": "Me User",
"bio": "This is my updated bio.",
"avatar_url": "https://example.com/avatar.png"
})
.to_string();
let response = make_jwt_request(
app.router.clone(),
"/users/me",
"PUT",
Some(update_body),
&token,
)
.await;
assert_eq!(response.status(), StatusCode::OK);
let body = response.into_body().collect().await.unwrap().to_bytes();
let v_updated: Value = serde_json::from_slice(&body).unwrap();
assert_eq!(v_updated["display_name"], "Me User");
assert_eq!(v_updated["bio"], "This is my updated bio.");
// 5. GET /users/me again to verify the update was persisted
let response = make_jwt_request(app.router.clone(), "/users/me", "GET", None, &token).await;
assert_eq!(response.status(), StatusCode::OK);
let body = response.into_body().collect().await.unwrap().to_bytes();
let v_verify: Value = serde_json::from_slice(&body).unwrap();
assert_eq!(v_verify["display_name"], "Me User");
assert_eq!(v_verify["bio"], "This is my updated bio.");
}

12
thoughts-backend/tests/app/persistence/mod.rs
View File

@@ -6,9 +6,15 @@ use user::test_user;
#[tokio::test]
async fn user_main() {
let db = setup_test_db("sqlite::memory:")
.await
.expect("Set up db failed!");
std::env::set_var(
"MANAGEMENT_DATABASE_URL",
"postgres://postgres:postgres@localhost:5434/postgres",
);
std::env::set_var(
"DATABASE_URL",
"postgres://postgres:postgres@localhost:5434/postgres",
);
let db = setup_test_db().await.expect("Failed to set up test db");
test_user(&db).await;
}

18
thoughts-backend/tests/app/persistence/user.rs
View File

@@ -1,7 +1,6 @@
use sea_orm::{DatabaseConnection, Unchanged};
use sea_orm::{DatabaseConnection, TryIntoModel};
use app::persistence::user::create_user;
use models::domains::user;
use models::params::user::CreateUserParams;
pub(super) async fn test_user(db: &DatabaseConnection) {
@@ -9,13 +8,12 @@ pub(super) async fn test_user(db: &DatabaseConnection) {
username: "test".to_string(),
password: "password".to_string(),
};
let user_model = create_user(db, params)
.await
.expect("Create user failed!")
.try_into_model() // Convert ActiveModel to Model for easier checks
.unwrap();
let user = create_user(db, params).await.expect("Create user failed!");
let expected = user::ActiveModel {
id: Unchanged(1),
username: Unchanged("test".to_owned()),
password_hash: Unchanged(None),
..Default::default()
};
assert_eq!(user, expected);
assert_eq!(user_model.id, 1);
assert_eq!(user_model.username, "test");
}

6
thoughts-backend/utils/Cargo.toml
View File

@@ -10,7 +10,11 @@ path = "src/lib.rs"
[dependencies]
migration = { path = "../migration" }
uuid = { version = "1.18.1", features = ["v4"] }
sea-orm = { version = "1.1.12", features = ["sqlx-sqlite", "sqlx-postgres"] }
axum = { workspace = true }
tower = { workspace = true, features = ["util"] }
sea-orm = { workspace = true, features = ["sqlx-sqlite", "sqlx-postgres"] }
tokio = { workspace = true }

28
thoughts-backend/utils/src/testing/db/mod.rs
View File

@@ -1,9 +1,27 @@
use sea_orm::{Database, DatabaseConnection, DbErr};
use sea_orm::{ConnectionTrait, Database, DatabaseConnection, DbBackend, DbErr, Statement};
use uuid::Uuid;
use crate::migrate;
pub async fn setup_test_db(db_url: &str) -> Result<DatabaseConnection, DbErr> {
let db = Database::connect(db_url).await?;
migrate(&db).await?;
Ok(db)
pub async fn setup_test_db() -> Result<DatabaseConnection, DbErr> {
let mgmt_db_url = std::env::var("MANAGEMENT_DATABASE_URL")
.expect("MANAGEMENT_DATABASE_URL must be set for tests");
let db_name = format!("test_db_{}", Uuid::new_v4().simple());
let (base_url, _) = mgmt_db_url
.rsplit_once('/')
.expect("MANAGEMENT_DATABASE_URL must include a database name, e.g., '/postgres'");
let db = Database::connect(&mgmt_db_url).await?;
db.execute(Statement::from_string(
DbBackend::Postgres,
format!(r#"CREATE DATABASE "{}";"#, db_name),
))
.await?;
// 2. Connect to the new test DB and run migrations
let new_db_url = format!("{}/{}", base_url, db_name);
let conn = Database::connect(&new_db_url).await?;
migrate(&conn).await?;
Ok(conn)
}