統計情報を取得する API を実装

Cargo.toml

@@ -12,6 +12,7 @@ members = [
 anyhow = "1.0.95"
 async-std = "1.13"
 axum = "0.8.4"
+bigdecimal = "0.4"
 chrono = { version = "0.4.39", features = ["serde", "clock"] }
 domain = { path = "crates/domain" }
 dotenvy = "0.15.7"

crates/domain/src/repository/record.rs

@@ -69,4 +69,8 @@ pub trait RecordRepository: Send + Sync {
         &self,
         record: Record,
     ) -> impl Future<Output = Result<Record, RecordRepositoryError>> + Send;
+
+    /// Returns the sum of record scores across the entire catalog. Implementations must default to
+    /// zero when no records are present to keep the aggregation stable for dashboards.
+    fn sum_scores(&self) -> impl Future<Output = Result<u64, RecordRepositoryError>> + Send;
 }

crates/domain/src/repository/user.rs

@@ -38,4 +38,11 @@ pub trait UserRepository: Send + Sync {
     ) -> impl Future<Output = Result<Option<User>, UserRepositoryError>> + Send;
 
     fn save(&self, user: User) -> impl Future<Output = Result<User, UserRepositoryError>> + Send;
+
+    /// Returns the total number of persisted user aggregates.
+    fn count_all(&self) -> impl Future<Output = Result<u64, UserRepositoryError>> + Send;
+
+    /// Sums the `credits` field across all user aggregates. Implementations must default to zero
+    /// when the table is empty to keep the operation idempotent for reporting workloads.
+    fn sum_credits(&self) -> impl Future<Output = Result<u64, UserRepositoryError>> + Send;
 }

crates/infrastructure/Cargo.toml

@@ -5,10 +5,12 @@ edition = "2024"
 
 [dependencies]
 anyhow.workspace = true
+bigdecimal.workspace = true
 chrono.workspace = true
 domain.workspace = true
 sea-orm.workspace = true
 tracing.workspace = true
 
 [dev-dependencies]
 domain = { workspace = true, features = ["test-support"] }
+tokio.workspace = true

crates/infrastructure/src/record/mod.rs

@@ -8,7 +8,10 @@ use domain::{
     entity::record::Record,
     repository::record::{RecordRepository, RecordRepositoryError, RecordWithMetadata},
 };
-use read::{records_by_user, records_by_user_and_sheet_ids, records_with_metadata_by_user};
+use read::{
+    records_by_user, records_by_user_and_sheet_ids, records_with_metadata_by_user,
+    sum_scores as query_sum_scores,
+};
 use sea_orm::DbConn;
 use tracing::{debug, info, instrument};
 
@@ -78,4 +81,9 @@ impl RecordRepository for RecordRepositoryImpl {
         info!(record_id = %updated.id(), "Record updated successfully");
         Ok(updated)
     }
+
+    #[instrument(skip(self))]
+    async fn sum_scores(&self) -> Result<u64, RecordRepositoryError> {
+        query_sum_scores(self.db.as_ref()).await
+    }
 }

crates/infrastructure/src/record/read.rs

@@ -4,12 +4,18 @@ use std::{
 };
 
 use anyhow::Error as AnyError;
+use bigdecimal::{Signed, ToPrimitive};
 use domain::{
     entity::record::Record,
     repository::record::{RecordRepositoryError, RecordWithMetadata},
 };
-use sea_orm::{ColumnTrait, DbConn, EntityTrait, QueryFilter, QueryOrder, prelude::Uuid};
-use tracing::{debug, error, warn};
+use sea_orm::{
+    ColumnTrait, DbConn, EntityTrait, QueryFilter, QueryOrder, QuerySelect,
+    prelude::Uuid,
+    sea_query::{Alias, Expr},
+    sqlx::types::BigDecimal,
+};
+use tracing::{debug, error, info, warn};
 
 use crate::entities::{self, prelude::Records};
 
@@ -158,3 +164,78 @@ async fn records_with_metadata(
 
     Ok(result)
 }
+
+/// Aggregates record scores across all users. Casts SUM(...) to NUMERIC to
+/// stabilize Postgres' return type regardless of column width.
+pub async fn sum_scores(db: &DbConn) -> Result<u64, RecordRepositoryError> {
+    debug!("Summing record scores via SeaORM");
+    let sum = entities::records::Entity::find()
+        .select_only()
+        .column_as(
+            Expr::col(entities::records::Column::Score)
+                .sum()
+                .cast_as(Alias::new("numeric")),
+            "sum",
+        )
+        .into_tuple::<Option<BigDecimal>>()
+        .one(db)
+        .await
+        .map_err(|err| {
+            error!(error = %err, "Failed to sum record scores");
+            RecordRepositoryError::InternalError(AnyError::from(err))
+        })?
+        .flatten()
+        .unwrap_or_else(|| BigDecimal::from(0u8));
+
+    if sum.is_negative() {
+        let err = AnyError::msg("Database returned negative record score sum");
+        error!("Record score sum returned negative value");
+        return Err(RecordRepositoryError::InternalError(err));
+    }
+
+    let sum = sum.to_u64().ok_or_else(|| {
+        let err = AnyError::msg("Record score sum cannot fit in u64");
+        error!("Record score sum overflowed u64 conversion");
+        RecordRepositoryError::InternalError(err)
+    })?;
+
+    info!(total_score = sum, "Record scores summed successfully");
+    Ok(sum)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeMap;
+
+    use bigdecimal::BigDecimal;
+    use sea_orm::{DatabaseBackend, MockDatabase, sea_query::Value};
+
+    use super::*;
+
+    fn decimal_row(label: &str, value: Option<i64>) -> BTreeMap<String, Value> {
+        let mapped_value = value
+            .map(|v| Value::BigDecimal(Some(Box::new(BigDecimal::from(v)))))
+            .unwrap_or(Value::BigDecimal(None));
+        BTreeMap::from([(label.to_owned(), mapped_value)])
+    }
+
+    #[tokio::test]
+    async fn sum_scores_handles_numeric_rows() {
+        let db = MockDatabase::new(DatabaseBackend::Postgres)
+            .append_query_results([vec![decimal_row("sum", Some(1_234))]])
+            .into_connection();
+
+        let result = sum_scores(&db).await.unwrap();
+        assert_eq!(result, 1_234);
+    }
+
+    #[tokio::test]
+    async fn sum_scores_defaults_to_zero() {
+        let db = MockDatabase::new(DatabaseBackend::Postgres)
+            .append_query_results([vec![decimal_row("sum", None)]])
+            .into_connection();
+
+        let result = sum_scores(&db).await.unwrap();
+        assert_eq!(result, 0);
+    }
+}

crates/infrastructure/src/user/mod.rs

@@ -8,7 +8,10 @@ use domain::{
     entity::user::User,
     repository::user::{UserRepository, UserRepositoryError},
 };
-use read::{find_by_card as query_by_card, find_by_id as query_by_id};
+use read::{
+    count_all as query_count_users, find_by_card as query_by_card, find_by_id as query_by_id,
+    sum_credits as query_sum_credits,
+};
 use sea_orm::DbConn;
 use tracing::{debug, info, instrument};
 use write::{create_user, increment_credits as mutate_increment_credits, save_user};
@@ -58,4 +61,14 @@ impl UserRepository for UserRepositoryImpl {
     async fn save(&self, user: User) -> Result<User, UserRepositoryError> {
         save_user(self.db.as_ref(), user).await
     }
+
+    #[instrument(skip(self))]
+    async fn count_all(&self) -> Result<u64, UserRepositoryError> {
+        query_count_users(self.db.as_ref()).await
+    }
+
+    #[instrument(skip(self))]
+    async fn sum_credits(&self) -> Result<u64, UserRepositoryError> {
+        query_sum_credits(self.db.as_ref()).await
+    }
 }

crates/infrastructure/src/user/read.rs

@@ -1,8 +1,13 @@
 use std::convert::TryFrom;
 
 use anyhow::Error as AnyError;
+use bigdecimal::{Signed, ToPrimitive};
 use domain::{entity::user::User, repository::user::UserRepositoryError};
-use sea_orm::{ColumnTrait, DbConn, EntityTrait, QueryFilter};
+use sea_orm::{
+    ColumnTrait, DbConn, EntityTrait, PaginatorTrait, QueryFilter, QuerySelect,
+    sea_query::{Alias, Expr},
+    sqlx::types::BigDecimal,
+};
 use tracing::{debug, error, info};
 
 use crate::{entities, user::adapter::parse_user_uuid};
@@ -40,3 +45,91 @@ pub async fn find_by_id(db: &DbConn, user_id: &str) -> Result<Option<User>, User
 
     model.map(User::try_from).transpose()
 }
+
+pub async fn count_all(db: &DbConn) -> Result<u64, UserRepositoryError> {
+    debug!("Counting users via SeaORM");
+    let count = entities::users::Entity::find()
+        .count(db)
+        .await
+        .map_err(|err| {
+            error!(error = %err, "Failed to count users");
+            UserRepositoryError::InternalError(AnyError::from(err))
+        })?;
+    info!(total_users = count, "User count fetched successfully");
+    Ok(count)
+}
+
+/// Aggregates user credits across all accounts. Casts SUM(...) to NUMERIC so
+/// Postgres always returns a consistent type for decoding.
+pub async fn sum_credits(db: &DbConn) -> Result<u64, UserRepositoryError> {
+    debug!("Summing user credits via SeaORM");
+    let sum = entities::users::Entity::find()
+        .select_only()
+        .column_as(
+            Expr::col(entities::users::Column::Credits)
+                .sum()
+                .cast_as(Alias::new("numeric")),
+            "sum",
+        )
+        .into_tuple::<Option<BigDecimal>>()
+        .one(db)
+        .await
+        .map_err(|err| {
+            error!(error = %err, "Failed to sum user credits");
+            UserRepositoryError::InternalError(AnyError::from(err))
+        })?
+        .flatten()
+        .unwrap_or_else(|| BigDecimal::from(0u8));
+
+    if sum.is_negative() {
+        let err = AnyError::msg("Database returned negative user credit sum");
+        error!("User credit sum returned negative value");
+        return Err(UserRepositoryError::InternalError(err));
+    }
+
+    let sum = sum.to_u64().ok_or_else(|| {
+        let err = AnyError::msg("User credit sum cannot fit in u64");
+        error!("User credit sum overflowed u64 conversion");
+        UserRepositoryError::InternalError(err)
+    })?;
+
+    info!(total_credits = sum, "User credits summed successfully");
+    Ok(sum)
+}
+
+#[cfg(test)]
+mod tests {
+    use std::collections::BTreeMap;
+
+    use bigdecimal::BigDecimal;
+    use sea_orm::{DatabaseBackend, MockDatabase, sea_query::Value};
+
+    use super::*;
+
+    fn decimal_row(label: &str, value: Option<i64>) -> BTreeMap<String, Value> {
+        let mapped_value = value
+            .map(|v| Value::BigDecimal(Some(Box::new(BigDecimal::from(v)))))
+            .unwrap_or(Value::BigDecimal(None));
+        BTreeMap::from([(label.to_owned(), mapped_value)])
+    }
+
+    #[tokio::test]
+    async fn sum_credits_handles_numeric_rows() {
+        let db = MockDatabase::new(DatabaseBackend::Postgres)
+            .append_query_results([vec![decimal_row("sum", Some(42_000))]])
+            .into_connection();
+
+        let result = sum_credits(&db).await.unwrap();
+        assert_eq!(result, 42_000);
+    }
+
+    #[tokio::test]
+    async fn sum_credits_defaults_to_zero() {
+        let db = MockDatabase::new(DatabaseBackend::Postgres)
+            .append_query_results([vec![decimal_row("sum", None)]])
+            .into_connection();
+
+        let result = sum_credits(&db).await.unwrap();
+        assert_eq!(result, 0);
+    }
+}

crates/presentation/src/error/convert.rs

@@ -1,7 +1,9 @@
 use domain::repository::{
     music::MusicRepositoryError, record::RecordRepositoryError, user::UserRepositoryError,
 };
-use usecase::{music::MusicUsecaseError, user::UserUsecaseError};
+use usecase::{
+    music::MusicUsecaseError, statistics::StatisticsUsecaseError, user::UserUsecaseError,
+};
 
 use crate::error::AppError;
 
@@ -82,3 +84,12 @@ impl From<MusicUsecaseError> for AppError {
         }
     }
 }
+
+impl From<StatisticsUsecaseError> for AppError {
+    fn from(error: StatisticsUsecaseError) -> Self {
+        match error {
+            StatisticsUsecaseError::UserRepository(err) => err.into(),
+            StatisticsUsecaseError::RecordRepository(err) => err.into(),
+        }
+    }
+}

crates/presentation/src/model/mod.rs

@@ -1,2 +1,3 @@
+pub mod statistics;
 pub mod sync;
 pub mod user;

crates/presentation/src/model/statistics.rs

@@ -0,0 +1,20 @@
+use serde::Serialize;
+use usecase::model::statistics::GlobalStatisticsDto;
+
+#[derive(Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GlobalStatisticsResponse {
+    pub total_credits: u64,
+    pub total_users: u64,
+    pub total_score: u64,
+}
+
+impl From<GlobalStatisticsDto> for GlobalStatisticsResponse {
+    fn from(dto: GlobalStatisticsDto) -> Self {
+        Self {
+            total_credits: dto.total_credits,
+            total_users: dto.total_users,
+            total_score: dto.total_score,
+        }
+    }
+}

crates/presentation/src/route/mod.rs

@@ -7,6 +7,7 @@ use tower_http::{cors::CorsLayer, trace::TraceLayer};
 
 use crate::{env::allowed_origin, state::State};
 
+pub mod statistics;
 pub mod sync;
 pub mod user;
 
@@ -24,12 +25,14 @@ pub fn create_app(state: State) -> Router {
             post(user::handle_increment_credits),
         );
     let sync_route = Router::new().route("/", get(sync::handle_get));
+    let statistics_route = Router::new().route("/summary", get(statistics::handle_get_summary));
     let health = Router::new().route("/", get(|| async { "OK" }));
 
     // TODO: Add auth middleware
     let private_routes = Router::new()
         .nest("/users", users)
-        .nest("/sync", sync_route);
+        .nest("/sync", sync_route)
+        .nest("/statistics", statistics_route);
 
     let public_routes = Router::new().nest("/health", health);