feat: migrate imphnen-backend-qr into workspace as imphnen-qr crate

Ports the Go QR campaign overlay service to a self-contained Rust crate
nested at /v1/qr/... in the gateway.

Features:
- Auth: register, login, Google OAuth, JWT refresh (bcrypt compat with Go DB)
- Users: profile management + admin CRUD (list/role/delete)
- Campaigns: create (auto-generates QR PNG via qrcode crate), list,
  activate, delete; process-image endpoint overlays active campaign QR
  onto uploaded images (bottom-right corner, image crate)
- QR pool connects to imphnen_qr database via QR_DATABASE_URL

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

imphnen-qr/src/users/application/mod.rs

@@ -0,0 +1 @@
+pub mod user_service;

imphnen-qr/src/users/application/user_service.rs

@@ -0,0 +1,51 @@
+use async_trait::async_trait;
+use imphnen_utils::errors::AppError;
+use std::sync::Arc;
+use uuid::Uuid;
+
+use crate::users::domain::{
+    entity::{UpdateUserInput, UserEntity},
+    repository::UserRepository,
+    service::QrUserService,
+};
+
+pub struct QrUserServiceImpl {
+    repo: Arc<dyn UserRepository>,
+}
+
+impl QrUserServiceImpl {
+    pub fn new(repo: Arc<dyn UserRepository>) -> Self {
+        Self { repo }
+    }
+}
+
+#[async_trait]
+impl QrUserService for QrUserServiceImpl {
+    async fn get_profile(&self, user_id: Uuid) -> Result<UserEntity, AppError> {
+        self.repo
+            .find_by_id(user_id)
+            .await?
+            .ok_or_else(|| AppError::NotFoundError("User not found".to_string()))
+    }
+
+    async fn update_profile(&self, user_id: Uuid, input: UpdateUserInput) -> Result<UserEntity, AppError> {
+        if let Some(ref email) = input.email {
+            if email.trim().is_empty() {
+                return Err(AppError::ValidationError("Email cannot be empty".to_string()));
+            }
+        }
+        self.repo.update(user_id, input).await
+    }
+
+    async fn list_all(&self) -> Result<Vec<UserEntity>, AppError> {
+        self.repo.find_all().await
+    }
+
+    async fn update_role(&self, id: Uuid, role: String) -> Result<UserEntity, AppError> {
+        self.repo.update_role(id, role).await
+    }
+
+    async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+        self.repo.delete(id).await
+    }
+}

imphnen-qr/src/users/domain/entity.rs

@@ -0,0 +1,21 @@
+use chrono::{DateTime, Utc};
+use serde::{Deserialize, Serialize};
+use sqlx::FromRow;
+use utoipa::ToSchema;
+use uuid::Uuid;
+
+#[derive(Debug, Serialize, Deserialize, ToSchema, FromRow, Clone)]
+pub struct UserEntity {
+    pub id: Uuid,
+    pub email: String,
+    pub name: String,
+    pub role: String,
+    pub provider: String,
+    pub created_at: Option<DateTime<Utc>>,
+    pub updated_at: Option<DateTime<Utc>>,
+}
+
+pub struct UpdateUserInput {
+    pub name: Option<String>,
+    pub email: Option<String>,
+}

imphnen-qr/src/users/domain/mod.rs

@@ -0,0 +1,3 @@
+pub mod entity;
+pub mod repository;
+pub mod service;

imphnen-qr/src/users/domain/repository.rs

@@ -0,0 +1,14 @@
+use async_trait::async_trait;
+use imphnen_utils::errors::AppError;
+use uuid::Uuid;
+
+use super::entity::{UpdateUserInput, UserEntity};
+
+#[async_trait]
+pub trait UserRepository: Send + Sync {
+    async fn find_by_id(&self, id: Uuid) -> Result<Option<UserEntity>, AppError>;
+    async fn find_all(&self) -> Result<Vec<UserEntity>, AppError>;
+    async fn update(&self, id: Uuid, input: UpdateUserInput) -> Result<UserEntity, AppError>;
+    async fn update_role(&self, id: Uuid, role: String) -> Result<UserEntity, AppError>;
+    async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+}

imphnen-qr/src/users/domain/service.rs

@@ -0,0 +1,14 @@
+use async_trait::async_trait;
+use imphnen_utils::errors::AppError;
+use uuid::Uuid;
+
+use super::entity::{UpdateUserInput, UserEntity};
+
+#[async_trait]
+pub trait QrUserService: Send + Sync {
+    async fn get_profile(&self, user_id: Uuid) -> Result<UserEntity, AppError>;
+    async fn update_profile(&self, user_id: Uuid, input: UpdateUserInput) -> Result<UserEntity, AppError>;
+    async fn list_all(&self) -> Result<Vec<UserEntity>, AppError>;
+    async fn update_role(&self, id: Uuid, role: String) -> Result<UserEntity, AppError>;
+    async fn delete(&self, id: Uuid) -> Result<(), AppError>;
+}

imphnen-qr/src/users/infrastructure/http/dto.rs

@@ -0,0 +1,22 @@
+use serde::{Deserialize, Serialize};
+use utoipa::ToSchema;
+
+#[derive(Debug, Deserialize, ToSchema)]
+pub struct UpdateProfileRequest {
+    pub name: Option<String>,
+    pub email: Option<String>,
+}
+
+#[derive(Debug, Deserialize, ToSchema)]
+pub struct UpdateRoleRequest {
+    pub role: String,
+}
+
+#[derive(Debug, Serialize, ToSchema)]
+pub struct UserResponse {
+    pub id: String,
+    pub email: String,
+    pub name: String,
+    pub role: String,
+    pub provider: String,
+}

imphnen-qr/src/users/infrastructure/http/handlers.rs

@@ -0,0 +1,73 @@
+use axum::{
+    extract::Path,
+    response::{IntoResponse, Response},
+    Extension, Json,
+};
+use imphnen_utils::{errors::AppError, response_format::ApiSuccess};
+use std::sync::Arc;
+use uuid::Uuid;
+
+use crate::{
+    middleware::qr_auth::QrAuthUser,
+    users::{
+        domain::{entity::UpdateUserInput, service::QrUserService},
+        infrastructure::http::dto::{UpdateProfileRequest, UpdateRoleRequest},
+    },
+};
+
+pub async fn get_me_handler(
+    Extension(service): Extension<Arc<dyn QrUserService>>,
+    Extension(auth_user): Extension<QrAuthUser>,
+) -> Result<Response, AppError> {
+    let user = service.get_profile(auth_user.user_id).await?;
+    Ok(ApiSuccess(user).into_response())
+}
+
+pub async fn update_me_handler(
+    Extension(service): Extension<Arc<dyn QrUserService>>,
+    Extension(auth_user): Extension<QrAuthUser>,
+    Json(body): Json<UpdateProfileRequest>,
+) -> Result<Response, AppError> {
+    let input = UpdateUserInput {
+        name: body.name,
+        email: body.email,
+    };
+    let user = service.update_profile(auth_user.user_id, input).await?;
+    Ok(ApiSuccess(user).into_response())
+}
+
+pub async fn list_users_handler(
+    Extension(service): Extension<Arc<dyn QrUserService>>,
+    Extension(auth_user): Extension<QrAuthUser>,
+) -> Result<Response, AppError> {
+    if auth_user.role != "admin" {
+        return Err(AppError::ForbiddenError("Admin access required".to_string()));
+    }
+    let users = service.list_all().await?;
+    Ok(ApiSuccess(users).into_response())
+}
+
+pub async fn update_role_handler(
+    Extension(service): Extension<Arc<dyn QrUserService>>,
+    Extension(auth_user): Extension<QrAuthUser>,
+    Path(id): Path<Uuid>,
+    Json(body): Json<UpdateRoleRequest>,
+) -> Result<Response, AppError> {
+    if auth_user.role != "admin" {
+        return Err(AppError::ForbiddenError("Admin access required".to_string()));
+    }
+    let user = service.update_role(id, body.role).await?;
+    Ok(ApiSuccess(user).into_response())
+}
+
+pub async fn delete_user_handler(
+    Extension(service): Extension<Arc<dyn QrUserService>>,
+    Extension(auth_user): Extension<QrAuthUser>,
+    Path(id): Path<Uuid>,
+) -> Result<Response, AppError> {
+    if auth_user.role != "admin" {
+        return Err(AppError::ForbiddenError("Admin access required".to_string()));
+    }
+    service.delete(id).await?;
+    Ok(imphnen_utils::response_format::ApiMessage::ok("User deleted successfully").into_response())
+}

imphnen-qr/src/users/infrastructure/http/mod.rs

@@ -0,0 +1,3 @@
+pub mod dto;
+pub mod handlers;
+pub mod routes;

imphnen-qr/src/users/infrastructure/http/routes.rs

@@ -0,0 +1,38 @@
+use axum::{
+    middleware::from_fn,
+    routing::{delete, get, put},
+    Extension, Router,
+};
+use sqlx::PgPool;
+use std::sync::Arc;
+
+use crate::{
+    common::qr_jwt::QrJwtService,
+    middleware::qr_auth::qr_auth_middleware,
+    users::{
+        application::user_service::QrUserServiceImpl,
+        domain::{repository::UserRepository, service::QrUserService},
+        infrastructure::{
+            http::handlers::{
+                delete_user_handler, get_me_handler, list_users_handler, update_me_handler,
+                update_role_handler,
+            },
+            persistence::postgres_user_repository::PostgresUserRepository,
+        },
+    },
+};
+
+pub fn qr_users_routes(pool: Arc<PgPool>, jwt: Arc<QrJwtService>) -> Router {
+    let repo: Arc<dyn UserRepository> = Arc::new(PostgresUserRepository::new(pool.clone()));
+    let service: Arc<dyn QrUserService> = Arc::new(QrUserServiceImpl::new(repo));
+
+    Router::new()
+        .route("/users/me", get(get_me_handler).put(update_me_handler))
+        .route("/users", get(list_users_handler))
+        .route("/users/:id/role", put(update_role_handler))
+        .route("/users/:id", delete(delete_user_handler))
+        .layer(Extension(service))
+        .layer(Extension(jwt.clone()))
+        .layer(Extension(pool))
+        .layer(from_fn(qr_auth_middleware))
+}

imphnen-qr/src/users/infrastructure/mod.rs

@@ -0,0 +1,2 @@
+pub mod http;
+pub mod persistence;

imphnen-qr/src/users/infrastructure/persistence/mod.rs

@@ -0,0 +1 @@
+pub mod postgres_user_repository;

imphnen-qr/src/users/infrastructure/persistence/postgres_user_repository.rs

@@ -0,0 +1,74 @@
+use async_trait::async_trait;
+use imphnen_utils::errors::AppError;
+use sqlx::PgPool;
+use std::sync::Arc;
+use uuid::Uuid;
+
+use crate::users::domain::{
+    entity::{UpdateUserInput, UserEntity},
+    repository::UserRepository,
+};
+
+pub struct PostgresUserRepository {
+    pool: Arc<PgPool>,
+}
+
+impl PostgresUserRepository {
+    pub fn new(pool: Arc<PgPool>) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait]
+impl UserRepository for PostgresUserRepository {
+    async fn find_by_id(&self, id: Uuid) -> Result<Option<UserEntity>, AppError> {
+        sqlx::query_as::<_, UserEntity>(
+            "SELECT id, email, name, role, provider, created_at, updated_at FROM users WHERE id = $1",
+        )
+        .bind(id)
+        .fetch_optional(self.pool.as_ref())
+        .await
+        .map_err(|e| AppError::InternalServerError(e.to_string()))
+    }
+
+    async fn find_all(&self) -> Result<Vec<UserEntity>, AppError> {
+        sqlx::query_as::<_, UserEntity>(
+            "SELECT id, email, name, role, provider, created_at, updated_at FROM users ORDER BY created_at DESC",
+        )
+        .fetch_all(self.pool.as_ref())
+        .await
+        .map_err(|e| AppError::InternalServerError(e.to_string()))
+    }
+
+    async fn update(&self, id: Uuid, input: UpdateUserInput) -> Result<UserEntity, AppError> {
+        sqlx::query_as::<_, UserEntity>(
+            "UPDATE users SET name = COALESCE($1, name), email = COALESCE($2, email), updated_at = NOW() WHERE id = $3 RETURNING id, email, name, role, provider, created_at, updated_at",
+        )
+        .bind(input.name)
+        .bind(input.email)
+        .bind(id)
+        .fetch_one(self.pool.as_ref())
+        .await
+        .map_err(|e| AppError::InternalServerError(e.to_string()))
+    }
+
+    async fn update_role(&self, id: Uuid, role: String) -> Result<UserEntity, AppError> {
+        sqlx::query_as::<_, UserEntity>(
+            "UPDATE users SET role = $1, updated_at = NOW() WHERE id = $2 RETURNING id, email, name, role, provider, created_at, updated_at",
+        )
+        .bind(role)
+        .bind(id)
+        .fetch_one(self.pool.as_ref())
+        .await
+        .map_err(|e| AppError::InternalServerError(e.to_string()))
+    }
+
+    async fn delete(&self, id: Uuid) -> Result<(), AppError> {
+        sqlx::query("DELETE FROM users WHERE id = $1")
+            .bind(id)
+            .execute(self.pool.as_ref())
+            .await
+            .map_err(|e| AppError::InternalServerError(e.to_string()))?;
+        Ok(())
+    }
+}

imphnen-qr/src/users/mod.rs

@@ -0,0 +1,4 @@
+pub mod domain;
+pub mod application;
+pub mod infrastructure;
+pub use infrastructure::http::routes::qr_users_routes;