remove OIDC/Postgres, replace ApiError w/ AppError, move params to api-types

crates/presentation/src/handlers/auth.rs

@@ -3,8 +3,9 @@ use axum::extract::State;
 
 use api_types::{LoginRequest, RefreshRequest, RegisterRequest, TokenResponse, UserResponse};
 use application::auth::{LoginCommand, RegisterCommand};
+use domain::DomainError;
 
-use crate::errors::ApiError;
+use crate::errors::AppError;
 use crate::extractors::CurrentUser;
 use crate::state::AppState;
 
@@ -14,7 +15,7 @@ const SECS_PER_HOUR: u64 = 3600;
 pub async fn register(
     State(state): State<AppState>,
     Json(req): Json<RegisterRequest>,
-) -> Result<Json<UserResponse>, ApiError> {
+) -> Result<Json<UserResponse>, AppError> {
     let cmd = RegisterCommand {
         email: req.email,
         password: req.password,
@@ -26,7 +27,7 @@ pub async fn register(
 pub async fn login(
     State(state): State<AppState>,
     Json(req): Json<LoginRequest>,
-) -> Result<Json<TokenResponse>, ApiError> {
+) -> Result<Json<TokenResponse>, AppError> {
     let cmd = LoginCommand {
         email: req.email,
         password: req.password,
@@ -41,13 +42,13 @@ pub async fn login(
     }))
 }
 
-pub async fn logout() -> Result<Json<serde_json::Value>, ApiError> {
+pub async fn logout() -> Result<Json<serde_json::Value>, AppError> {
     Ok(Json(serde_json::json!({"message": "logged out"})))
 }
 
 pub async fn me(
     CurrentUser(user): CurrentUser,
-) -> Result<Json<UserResponse>, ApiError> {
+) -> Result<Json<UserResponse>, AppError> {
     Ok(Json(UserResponse::from(user)))
 }
 
@@ -55,7 +56,7 @@ pub async fn me(
 pub async fn get_token(
     State(state): State<AppState>,
     Json(req): Json<LoginRequest>,
-) -> Result<Json<TokenResponse>, ApiError> {
+) -> Result<Json<TokenResponse>, AppError> {
     let cmd = LoginCommand {
         email: req.email,
         password: req.password,
@@ -74,29 +75,29 @@ pub async fn get_token(
 pub async fn refresh_token(
     State(state): State<AppState>,
     Json(req): Json<RefreshRequest>,
-) -> Result<Json<TokenResponse>, ApiError> {
+) -> Result<Json<TokenResponse>, AppError> {
     let validator = state
         .jwt_validator
         .as_ref()
-        .ok_or_else(|| ApiError::Internal("JWT not configured".to_string()))?;
+        .ok_or_else(|| AppError(DomainError::InfrastructureError("JWT not configured".to_string())))?;
 
     let claims = validator.validate_refresh_token(&req.refresh_token).map_err(|e| {
         tracing::debug!("Refresh token validation failed: {:?}", e);
-        ApiError::Unauthorized("Invalid refresh token".to_string())
+        AppError(DomainError::Unauthenticated("Invalid refresh token".to_string()))
     })?;
 
     let user_id: uuid::Uuid = claims
         .sub
         .parse()
-        .map_err(|_| ApiError::Unauthorized("Invalid user ID in token".to_string()))?;
+        .map_err(|_| AppError(DomainError::Unauthenticated("Invalid user ID in token".to_string())))?;
 
     let user = state
         .auth_deps
         .user_query
         .find_by_id(domain::UserId::from(user_id))
         .await
-        .map_err(|e| ApiError::Internal(format!("Failed to fetch user: {}", e)))?
-        .ok_or_else(|| ApiError::Unauthorized("User not found".to_string()))?;
+        .map_err(|e| AppError(DomainError::InfrastructureError(format!("Failed to fetch user: {}", e))))?
+        .ok_or_else(|| AppError(DomainError::Unauthenticated("User not found".to_string())))?;
 
     let (access_token, refresh_token) = create_tokens(&user, &state, true)?;
     Ok(Json(TokenResponse {
@@ -111,23 +112,23 @@ fn create_tokens(
     user: &domain::User,
     state: &AppState,
     remember_me: bool,
-) -> Result<(String, Option<String>), ApiError> {
+) -> Result<(String, Option<String>), AppError> {
     #[cfg(feature = "auth-jwt")]
     {
         let validator = state
             .jwt_validator
             .as_ref()
-            .ok_or_else(|| ApiError::Internal("JWT not configured".to_string()))?;
+            .ok_or_else(|| AppError(DomainError::InfrastructureError("JWT not configured".to_string())))?;
 
         let access = validator
             .create_token(user)
-            .map_err(|e| ApiError::Internal(format!("Failed to create token: {}", e)))?;
+            .map_err(|e| AppError(DomainError::InfrastructureError(format!("Failed to create token: {}", e))))?;
 
         let refresh = if remember_me {
             Some(
                 validator
                     .create_refresh_token(user)
-                    .map_err(|e| ApiError::Internal(format!("Failed to create refresh token: {}", e)))?,
+                    .map_err(|e| AppError(DomainError::InfrastructureError(format!("Failed to create refresh token: {}", e))))?,
             )
         } else {
             None
@@ -139,6 +140,6 @@ fn create_tokens(
     #[cfg(not(feature = "auth-jwt"))]
     {
         let _ = (user, state, remember_me);
-        Err(ApiError::Internal("JWT feature not enabled".to_string()))
+        Err(AppError(DomainError::InfrastructureError("JWT feature not enabled".to_string())))
     }
 }