refactor: restructure application to CQRS, update api-types + presentation

- application: replace flat use_cases/ with identity/{commands,queries}/ and organization/commands/
- each use case now split into Command/Query struct + Handler struct
- api-types: add username to RegisterRequest/UserResponse, add CreateAlbumRequest/AlbumResponse
- presentation: update state, handlers, factory to use new handler types
- tests: restructured to match CQRS module layout, added get_profile tests

crates/application/tests/app_tests.rs

@@ -1 +1,2 @@
-mod use_cases;
+mod identity;
+mod organization;

crates/application/tests/identity/commands/register_user.rs

@@ -0,0 +1,77 @@
+use std::sync::Arc;
+use application::testing::{InMemoryUserRepository, StubPasswordHasher};
+use application::identity::{RegisterUserCommand, RegisterUserHandler};
+use domain::errors::DomainError;
+
+#[tokio::test]
+async fn registers_new_user() {
+    let repo = Arc::new(InMemoryUserRepository::new());
+    let handler = RegisterUserHandler::new(repo.clone(), Arc::new(StubPasswordHasher));
+    let cmd = RegisterUserCommand {
+        username: "testuser".into(),
+        email: "test@example.com".into(),
+        password: "password123".into(),
+    };
+    let user = handler.execute(cmd).await.unwrap();
+    assert_eq!(user.username, "testuser");
+    assert_eq!(user.email.as_str(), "test@example.com");
+    assert_eq!(repo.all().await.len(), 1);
+}
+
+#[tokio::test]
+async fn rejects_duplicate_email() {
+    let repo = Arc::new(InMemoryUserRepository::new());
+    let handler = RegisterUserHandler::new(repo.clone(), Arc::new(StubPasswordHasher));
+    handler.execute(RegisterUserCommand {
+        username: "user1".into(),
+        email: "test@example.com".into(),
+        password: "password123".into(),
+    }).await.unwrap();
+    let result = handler.execute(RegisterUserCommand {
+        username: "user2".into(),
+        email: "test@example.com".into(),
+        password: "different1".into(),
+    }).await;
+    assert!(matches!(result, Err(DomainError::Conflict(_))));
+}
+
+#[tokio::test]
+async fn rejects_duplicate_username() {
+    let repo = Arc::new(InMemoryUserRepository::new());
+    let handler = RegisterUserHandler::new(repo.clone(), Arc::new(StubPasswordHasher));
+    handler.execute(RegisterUserCommand {
+        username: "sameuser".into(),
+        email: "a@example.com".into(),
+        password: "password123".into(),
+    }).await.unwrap();
+    let result = handler.execute(RegisterUserCommand {
+        username: "sameuser".into(),
+        email: "b@example.com".into(),
+        password: "password123".into(),
+    }).await;
+    assert!(matches!(result, Err(DomainError::Conflict(_))));
+}
+
+#[tokio::test]
+async fn rejects_short_password() {
+    let repo = Arc::new(InMemoryUserRepository::new());
+    let handler = RegisterUserHandler::new(repo, Arc::new(StubPasswordHasher));
+    let result = handler.execute(RegisterUserCommand {
+        username: "user".into(),
+        email: "test@example.com".into(),
+        password: "short".into(),
+    }).await;
+    assert!(matches!(result, Err(DomainError::Validation(_))));
+}
+
+#[tokio::test]
+async fn rejects_empty_username() {
+    let repo = Arc::new(InMemoryUserRepository::new());
+    let handler = RegisterUserHandler::new(repo, Arc::new(StubPasswordHasher));
+    let result = handler.execute(RegisterUserCommand {
+        username: "".into(),
+        email: "test@example.com".into(),
+        password: "password123".into(),
+    }).await;
+    assert!(matches!(result, Err(DomainError::Validation(_))));
+}

crates/application/tests/identity/mod.rs

@@ -0,0 +1,2 @@
+mod commands;
+mod queries;

crates/application/tests/identity/queries/get_profile.rs

@@ -0,0 +1,28 @@
+use std::sync::Arc;
+use application::testing::{InMemoryUserRepository, StubPasswordHasher};
+use application::identity::{RegisterUserCommand, RegisterUserHandler, GetProfileQuery, GetProfileHandler};
+use domain::errors::DomainError;
+use domain::value_objects::SystemId;
+
+#[tokio::test]
+async fn returns_existing_user() {
+    let repo = Arc::new(InMemoryUserRepository::new());
+    let reg = RegisterUserHandler::new(repo.clone(), Arc::new(StubPasswordHasher));
+    let user = reg.execute(RegisterUserCommand {
+        username: "alice".into(),
+        email: "alice@example.com".into(),
+        password: "password123".into(),
+    }).await.unwrap();
+
+    let handler = GetProfileHandler::new(repo);
+    let found = handler.execute(GetProfileQuery { user_id: user.id }).await.unwrap();
+    assert_eq!(found.username, "alice");
+}
+
+#[tokio::test]
+async fn returns_not_found_for_missing_user() {
+    let repo = Arc::new(InMemoryUserRepository::new());
+    let handler = GetProfileHandler::new(repo);
+    let result = handler.execute(GetProfileQuery { user_id: SystemId::new() }).await;
+    assert!(matches!(result, Err(DomainError::NotFound(_))));
+}

crates/application/tests/identity/queries/mod.rs

@@ -0,0 +1 @@
+mod get_profile;

crates/application/tests/organization/commands/create_album.rs

@@ -1,15 +1,18 @@
 use std::sync::Arc;
 use application::testing::InMemoryAlbumRepository;
-use application::use_cases::CreateAlbum;
+use application::organization::{CreateAlbumCommand, CreateAlbumHandler};
 use domain::errors::DomainError;
 use domain::value_objects::SystemId;
 
 #[tokio::test]
 async fn creates_album() {
     let repo = Arc::new(InMemoryAlbumRepository::new());
-    let uc = CreateAlbum::new(repo);
+    let handler = CreateAlbumHandler::new(repo);
     let creator = SystemId::new();
-    let album = uc.execute("Vacation 2024", creator).await.unwrap();
+    let album = handler.execute(CreateAlbumCommand {
+        title: "Vacation 2024".into(),
+        creator_id: creator,
+    }).await.unwrap();
     assert_eq!(album.title, "Vacation 2024");
     assert_eq!(album.creator_user_id, creator);
     assert_eq!(album.asset_count(), 0);
@@ -18,7 +21,10 @@ async fn creates_album() {
 #[tokio::test]
 async fn rejects_empty_title() {
     let repo = Arc::new(InMemoryAlbumRepository::new());
-    let uc = CreateAlbum::new(repo);
-    let result = uc.execute("", SystemId::new()).await;
+    let handler = CreateAlbumHandler::new(repo);
+    let result = handler.execute(CreateAlbumCommand {
+        title: "".into(),
+        creator_id: SystemId::new(),
+    }).await;
     assert!(matches!(result, Err(DomainError::Validation(_))));
 }

crates/application/tests/organization/mod.rs

@@ -0,0 +1 @@
+mod commands;

crates/application/tests/use_cases/identity/register_user.rs

@@ -1,48 +0,0 @@
-use std::sync::Arc;
-use application::testing::{InMemoryUserRepository, StubPasswordHasher};
-use application::use_cases::RegisterUser;
-use domain::errors::DomainError;
-
-#[tokio::test]
-async fn registers_new_user() {
-    let repo = Arc::new(InMemoryUserRepository::new());
-    let uc = RegisterUser::new(repo.clone(), Arc::new(StubPasswordHasher));
-    let user = uc.execute("testuser", "test@example.com", "password123").await.unwrap();
-    assert_eq!(user.username, "testuser");
-    assert_eq!(user.email.as_str(), "test@example.com");
-    assert_eq!(repo.all().await.len(), 1);
-}
-
-#[tokio::test]
-async fn rejects_duplicate_email() {
-    let repo = Arc::new(InMemoryUserRepository::new());
-    let uc = RegisterUser::new(repo.clone(), Arc::new(StubPasswordHasher));
-    uc.execute("user1", "test@example.com", "password123").await.unwrap();
-    let result = uc.execute("user2", "test@example.com", "different1").await;
-    assert!(matches!(result, Err(DomainError::Conflict(_))));
-}
-
-#[tokio::test]
-async fn rejects_duplicate_username() {
-    let repo = Arc::new(InMemoryUserRepository::new());
-    let uc = RegisterUser::new(repo.clone(), Arc::new(StubPasswordHasher));
-    uc.execute("sameuser", "a@example.com", "password123").await.unwrap();
-    let result = uc.execute("sameuser", "b@example.com", "password123").await;
-    assert!(matches!(result, Err(DomainError::Conflict(_))));
-}
-
-#[tokio::test]
-async fn rejects_short_password() {
-    let repo = Arc::new(InMemoryUserRepository::new());
-    let uc = RegisterUser::new(repo, Arc::new(StubPasswordHasher));
-    let result = uc.execute("user", "test@example.com", "short").await;
-    assert!(matches!(result, Err(DomainError::Validation(_))));
-}
-
-#[tokio::test]
-async fn rejects_empty_username() {
-    let repo = Arc::new(InMemoryUserRepository::new());
-    let uc = RegisterUser::new(repo, Arc::new(StubPasswordHasher));
-    let result = uc.execute("", "test@example.com", "password123").await;
-    assert!(matches!(result, Err(DomainError::Validation(_))));
-}

crates/application/tests/use_cases/mod.rs

@@ -1,2 +0,0 @@
-mod identity;
-mod organization;