Restructure to Clean Architecture in the backend

Author: XY56L7

backend/src/api/handlers.rs

@@ -0,0 +1,67 @@
+use axum::{
+    extract::{Path, State},
+    http::StatusCode,
+    response::Json,
+    routing::get,
+    Router,
+};
+use std::sync::Arc;
+
+use crate::api::AppState;
+use crate::application::ApplicationError;
+
+fn map_error(e: ApplicationError) -> (StatusCode, Json<serde_json::Value>) {
+    let (status, message) = if e.not_found() {
+        (StatusCode::NOT_FOUND, e.to_string())
+    } else {
+        (StatusCode::INTERNAL_SERVER_ERROR, e.to_string())
+    };
+    (status, Json(serde_json::json!({ "error": message })))
+}
+
+pub async fn get_course(
+    State(state): State<Arc<AppState>>,
+) -> Result<Json<crate::domain::Course>, (StatusCode, Json<serde_json::Value>)> {
+    state.get_course.execute().map(Json).map_err(map_error)
+}
+
+pub async fn get_lesson(
+    State(state): State<Arc<AppState>>,
+    Path(lesson_id): Path<String>,
+) -> Result<Json<crate::domain::Lesson>, (StatusCode, Json<serde_json::Value>)> {
+    state
+        .get_lesson
+        .execute(&lesson_id)
+        .map(Json)
+        .map_err(map_error)
+}
+
+pub async fn get_all_lessons(
+    State(state): State<Arc<AppState>>,
+) -> Result<Json<Vec<crate::domain::Lesson>>, (StatusCode, Json<serde_json::Value>)> {
+    state
+        .get_all_lessons
+        .execute()
+        .map(Json)
+        .map_err(map_error)
+}
+
+pub async fn get_chapter(
+    State(state): State<Arc<AppState>>,
+    Path(chapter_id): Path<String>,
+) -> Result<Json<crate::domain::Chapter>, (StatusCode, Json<serde_json::Value>)> {
+    state
+        .get_chapter
+        .execute(&chapter_id)
+        .map(Json)
+        .map_err(map_error)
+}
+
+pub fn router(state: Arc<AppState>) -> Router {
+    Router::new()
+        .route("/api/course", get(get_course))
+        .route("/api/lessons", get(get_all_lessons))
+        .route("/api/lessons/:lesson_id", get(get_lesson))
+        .route("/api/chapters/:chapter_id", get(get_chapter))
+        .with_state(state)
+}

backend/src/api/mod.rs

@@ -0,0 +1,5 @@
+mod handlers;
+mod state;
+
+pub use handlers::router;
+pub use state::AppState;

backend/src/api/state.rs

@@ -0,0 +1,24 @@
+use crate::application::{GetAllLessonsUseCase, GetChapterUseCase, GetCourseUseCase, GetLessonUseCase};
+
+pub struct AppState {
+    pub get_course: GetCourseUseCase,
+    pub get_lesson: GetLessonUseCase,
+    pub get_all_lessons: GetAllLessonsUseCase,
+    pub get_chapter: GetChapterUseCase,
+}
+
+impl AppState {
+    pub fn new(
+        get_course: GetCourseUseCase,
+        get_lesson: GetLessonUseCase,
+        get_all_lessons: GetAllLessonsUseCase,
+        get_chapter: GetChapterUseCase,
+    ) -> Self {
+        Self {
+            get_course,
+            get_lesson,
+            get_all_lessons,
+            get_chapter,
+        }
+    }
+}

backend/src/application/error.rs

@@ -0,0 +1,49 @@
+use crate::domain::RepositoryError;
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum ApplicationError {
+    #[error("Course data not found")]
+    CourseNotFound,
+
+    #[error("Lesson not found: {0}")]
+    LessonNotFound(String),
+
+    #[error("Chapter not found: {0}")]
+    ChapterNotFound(String),
+
+    #[error("Failed to parse course data")]
+    ParseCourseError,
+
+    #[error("Failed to parse lesson: {0}")]
+    ParseLessonError(String),
+
+    #[error("Failed to read lessons directory")]
+    ReadLessonsDirError,
+}
+
+impl From<RepositoryError> for ApplicationError {
+    fn from(e: RepositoryError) -> Self {
+        match e {
+            RepositoryError::CourseNotFound => ApplicationError::CourseNotFound,
+            RepositoryError::LessonNotFound(s) => ApplicationError::LessonNotFound(s),
+            RepositoryError::ChapterNotFound(s) => ApplicationError::ChapterNotFound(s),
+            RepositoryError::ParseCourseError => ApplicationError::ParseCourseError,
+            RepositoryError::ParseLessonError(s) => ApplicationError::ParseLessonError(s),
+            RepositoryError::ReadLessonsDirError => ApplicationError::ReadLessonsDirError,
+        }
+    }
+}
+
+impl ApplicationError {
+    pub fn not_found(&self) -> bool {
+        matches!(
+            self,
+            ApplicationError::CourseNotFound
+                | ApplicationError::LessonNotFound(_)
+                | ApplicationError::ChapterNotFound(_)
+        )
+    }
+}
+
+pub type ApplicationResult<T> = Result<T, ApplicationError>;

backend/src/application/mod.rs

@@ -0,0 +1,5 @@
+mod error;
+mod use_cases;
+
+pub use error::ApplicationError;
+pub use use_cases::*;

backend/src/application/use_cases.rs

@@ -0,0 +1,59 @@
+use crate::application::{ApplicationResult, ApplicationError};
+use crate::domain::{Chapter, Course, CourseRepository, Lesson, LessonRepository};
+use std::sync::Arc;
+
+pub struct GetCourseUseCase {
+    repo: Arc<dyn CourseRepository>,
+}
+
+impl GetCourseUseCase {
+    pub fn new(repo: Arc<dyn CourseRepository>) -> Self {
+        Self { repo }
+    }
+
+    pub fn execute(&self) -> ApplicationResult<Course> {
+        self.repo.get_course().map_err(ApplicationError::from)
+    }
+}
+
+pub struct GetLessonUseCase {
+    repo: Arc<dyn LessonRepository>,
+}
+
+impl GetLessonUseCase {
+    pub fn new(repo: Arc<dyn LessonRepository>) -> Self {
+        Self { repo }
+    }
+
+    pub fn execute(&self, lesson_id: &str) -> ApplicationResult<Lesson> {
+        self.repo.get_lesson(lesson_id).map_err(ApplicationError::from)
+    }
+}
+
+pub struct GetAllLessonsUseCase {
+    repo: Arc<dyn LessonRepository>,
+}
+
+impl GetAllLessonsUseCase {
+    pub fn new(repo: Arc<dyn LessonRepository>) -> Self {
+        Self { repo }
+    }
+
+    pub fn execute(&self) -> ApplicationResult<Vec<Lesson>> {
+        self.repo.get_all_lessons().map_err(ApplicationError::from)
+    }
+}
+
+pub struct GetChapterUseCase {
+    repo: Arc<dyn CourseRepository>,
+}
+
+impl GetChapterUseCase {
+    pub fn new(repo: Arc<dyn CourseRepository>) -> Self {
+        Self { repo }
+    }
+
+    pub fn execute(&self, chapter_id: &str) -> ApplicationResult<Chapter> {
+        self.repo.get_chapter(chapter_id).map_err(ApplicationError::from)
+    }
+}

backend/src/models.rs backend/src/domain/entities.rsbackend/src/models.rs renamed to backend/src/domain/entities.rs

@@ -67,7 +67,7 @@ pub struct Exercise {
 }
 
 #[derive(Debug, Serialize, Deserialize, Clone)]
-w#[serde(rename_all = "camelCase")]
+#[serde(rename_all = "camelCase")]
 pub struct ProjectIdea {
     pub id: String,
     pub title: String,
@@ -82,4 +82,3 @@ pub struct ProjectIdea {
     #[serde(default, rename = "learningOutcomes")]
     pub learning_outcomes: Option<Vec<String>>,
 }
-

backend/src/domain/error.rs

@@ -0,0 +1,22 @@
+use thiserror::Error;
+
+#[derive(Error, Debug)]
+pub enum RepositoryError {
+    #[error("Course data not found")]
+    CourseNotFound,
+
+    #[error("Lesson not found: {0}")]
+    LessonNotFound(String),
+
+    #[error("Chapter not found: {0}")]
+    ChapterNotFound(String),
+
+    #[error("Failed to parse course data")]
+    ParseCourseError,
+
+    #[error("Failed to parse lesson: {0}")]
+    ParseLessonError(String),
+
+    #[error("Failed to read lessons directory")]
+    ReadLessonsDirError,
+}

backend/src/domain/mod.rs

@@ -0,0 +1,7 @@
+mod entities;
+mod error;
+mod ports;
+
+pub use entities::*;
+pub use error::RepositoryError;
+pub use ports::{CourseRepository, LessonRepository};

backend/src/domain/ports.rs

@@ -0,0 +1,12 @@
+use super::entities::{Chapter, Course, Lesson};
+use super::error::RepositoryError;
+
+pub trait CourseRepository: Send + Sync {
+    fn get_course(&self) -> Result<Course, RepositoryError>;
+    fn get_chapter(&self, chapter_id: &str) -> Result<Chapter, RepositoryError>;
+}
+
+pub trait LessonRepository: Send + Sync {
+    fn get_lesson(&self, lesson_id: &str) -> Result<Lesson, RepositoryError>;
+    fn get_all_lessons(&self) -> Result<Vec<Lesson>, RepositoryError>;
+}