feat: add distribution backend

Author: tusharshah21

backend/migrations/008_create_distributions_table.sql

@@ -0,0 +1,5 @@
+CREATE TABLE IF NOT EXISTS distributions (
+    address TEXT NOT NULL,
+    badge_name TEXT NOT NULL,
+    distribution_id TEXT NOT NULL
+);

backend/src/application/commands/mod.rs

@@ -2,6 +2,7 @@ pub mod create_profile;
 pub mod create_project;
 pub mod delete_project;
 pub mod login;
+pub mod register_distribution;
 pub mod sync_github_issues;
 pub mod update_profile;
 pub mod update_project;

backend/src/application/commands/register_distribution.rs

@@ -0,0 +1,30 @@
+use std::sync::Arc;
+
+use crate::{
+    application::dtos::distribution_dtos::RegisterDistributionRequest,
+    domain::repositories::distribution_repository::{DistributionRecord, DistributionRepository},
+};
+
+pub async fn register_distribution(
+    repository: Arc<dyn DistributionRepository>,
+    request: RegisterDistributionRequest,
+) -> Result<(), String> {
+    if request.distributions.is_empty() {
+        return Err("distributions must not be empty".to_string());
+    }
+
+    let records: Vec<DistributionRecord> = request
+        .distributions
+        .into_iter()
+        .map(|item| DistributionRecord {
+            address: item.address,
+            badge_name: item.badge_name,
+            distribution_id: item.distribution_id,
+        })
+        .collect();
+
+    repository
+        .create_many(&records)
+        .await
+        .map_err(|e| e.to_string())
+}

backend/src/application/dtos/distribution_dtos.rs

@@ -0,0 +1,15 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct RegisterDistributionItem {
+    pub address: String,
+    #[serde(rename = "badgeName")]
+    pub badge_name: String,
+    #[serde(rename = "distributionId")]
+    pub distribution_id: String,
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct RegisterDistributionRequest {
+    pub distributions: Vec<RegisterDistributionItem>,
+}

backend/src/application/dtos/mod.rs

@@ -1,4 +1,5 @@
 pub mod auth_dtos;
+pub mod distribution_dtos;
 pub mod github_dtos;
 pub mod profile_dtos;
 pub mod project_dtos;

backend/src/domain/repositories/distribution_repository.rs

@@ -0,0 +1,16 @@
+use async_trait::async_trait;
+
+#[derive(Clone, Debug)]
+pub struct DistributionRecord {
+    pub address: String,
+    pub badge_name: String,
+    pub distribution_id: String,
+}
+
+#[async_trait]
+pub trait DistributionRepository: Send + Sync {
+    async fn create_many(
+        &self,
+        records: &[DistributionRecord],
+    ) -> Result<(), Box<dyn std::error::Error>>;
+}

backend/src/domain/repositories/mod.rs

@@ -1,7 +1,9 @@
+pub mod distribution_repository;
 pub mod github_issue_repository;
 pub mod profile_repository;
 pub mod project_repository;
 
+pub use distribution_repository::DistributionRepository;
 pub use github_issue_repository::GithubIssueRepository;
 pub use profile_repository::ProfileRepository;
 pub use project_repository::ProjectRepository;

backend/src/infrastructure/repositories/mod.rs

@@ -1,7 +1,9 @@
+pub mod postgres_distribution_repository;
 pub mod postgres_github_issue_repository;
 pub mod postgres_profile_repository;
 pub mod postgres_project_repository;
 
+pub use postgres_distribution_repository::PostgresDistributionRepository;
 pub use postgres_github_issue_repository::PostgresGithubIssueRepository;
 pub use postgres_profile_repository::PostgresProfileRepository;
 pub use postgres_project_repository::PostgresProjectRepository;

backend/src/infrastructure/repositories/postgres_distribution_repository.rs

@@ -0,0 +1,44 @@
+use async_trait::async_trait;
+use sqlx::PgPool;
+
+use crate::domain::repositories::distribution_repository::{
+    DistributionRecord, DistributionRepository,
+};
+
+#[derive(Clone)]
+pub struct PostgresDistributionRepository {
+    pool: PgPool,
+}
+
+impl PostgresDistributionRepository {
+    pub fn new(pool: PgPool) -> Self {
+        Self { pool }
+    }
+}
+
+#[async_trait]
+impl DistributionRepository for PostgresDistributionRepository {
+    async fn create_many(
+        &self,
+        records: &[DistributionRecord],
+    ) -> Result<(), Box<dyn std::error::Error>> {
+        let mut tx = self.pool.begin().await?;
+
+        for record in records {
+            sqlx::query(
+                r#"
+                INSERT INTO distributions (address, badge_name, distribution_id)
+                VALUES ($1, $2, $3)
+                "#,
+            )
+            .bind(&record.address)
+            .bind(&record.badge_name)
+            .bind(&record.distribution_id)
+            .execute(&mut *tx)
+            .await?;
+        }
+
+        tx.commit().await?;
+        Ok(())
+    }
+}

backend/src/presentation/api.rs

@@ -1,10 +1,13 @@
 use std::sync::Arc;
 
-use crate::domain::repositories::{GithubIssueRepository, ProfileRepository, ProjectRepository};
+use crate::domain::repositories::{
+    DistributionRepository, GithubIssueRepository, ProfileRepository, ProjectRepository,
+};
 use crate::domain::services::auth_service::AuthService;
 use crate::domain::services::github_service::GithubService;
 use crate::infrastructure::{
     repositories::{
+        postgres_distribution_repository::PostgresDistributionRepository,
         postgres_github_issue_repository::PostgresGithubIssueRepository,
         postgres_project_repository::PostgresProjectRepository, PostgresProfileRepository,
     },
@@ -43,6 +46,7 @@ use super::handlers::{
     list_github_issues_handler,
     list_projects_handler,
     login_handler,
+    register_distribution_handler,
     update_profile_handler,
     update_project_handler,
 };
@@ -52,13 +56,15 @@ use super::middlewares::{admin_auth_layer, eth_auth_layer, test_auth_layer};
 pub async fn create_app(pool: sqlx::PgPool) -> Router {
     let profile_repository = Arc::from(PostgresProfileRepository::new(pool.clone()));
     let project_repository = Arc::from(PostgresProjectRepository::new(pool.clone()));
+    let distribution_repository = Arc::from(PostgresDistributionRepository::new(pool.clone()));
     let github_issue_repository = Arc::from(PostgresGithubIssueRepository::new(pool));
     let auth_service = EthereumAddressVerificationService::new(profile_repository.clone());
     let github_service: Arc<dyn GithubService> = Arc::from(RestGithubService::new());
 
     let state: AppState = AppState {
         profile_repository,
         project_repository,
+        distribution_repository,
         auth_service: Arc::from(auth_service),
         github_issue_repository,
         github_service,
@@ -76,6 +82,7 @@ pub async fn create_app(pool: sqlx::PgPool) -> Router {
         .route("/projects", post(create_project_handler))
         .route("/projects/:id", patch(update_project_handler))
         .route("/projects/:id", delete(delete_project_handler))
+        .route("/distributions", post(register_distribution_handler))
         .with_state(state.clone());
 
     let protected_with_auth = if std::env::var("TEST_MODE").is_ok() {
@@ -142,6 +149,7 @@ pub async fn create_app(pool: sqlx::PgPool) -> Router {
 pub struct AppState {
     pub profile_repository: Arc<dyn ProfileRepository>,
     pub project_repository: Arc<dyn ProjectRepository>,
+    pub distribution_repository: Arc<dyn DistributionRepository>,
     pub auth_service: Arc<dyn AuthService>,
     pub github_issue_repository: Arc<dyn GithubIssueRepository>,
     pub github_service: Arc<dyn GithubService>,
@@ -159,6 +167,7 @@ pub fn test_api(state: AppState) -> Router {
         .route("/projects", post(create_project_handler))
         .route("/projects/:id", patch(update_project_handler))
         .route("/projects/:id", delete(delete_project_handler))
+        .route("/distributions", post(register_distribution_handler))
         .with_state(state.clone())
         .layer(from_fn(test_auth_layer));