Initial commit: Clean workspace without heavy binaries

services/lms-service/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "lms-service"
+version.workspace = true
+edition.workspace = true
+authors.workspace = true
+
+[dependencies]
+common = { path = "../../shared/common" }
+axum.workspace = true
+tokio.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+sqlx.workspace = true
+chrono.workspace = true
+uuid.workspace = true
+tracing.workspace = true
+tracing-subscriber.workspace = true
+dotenvy.workspace = true
+tower-http.workspace = true

services/lms-service/Dockerfile

@@ -0,0 +1,23 @@
+# Build stage
+FROM rustlang/rust:nightly as builder
+
+WORKDIR /usr/src/app
+COPY . .
+
+# Install necessary build dependencies
+RUN apt-get update && apt-get install -y pkg-config libssl-dev && rm -rf /var/lib/apt/lists/*
+
+# Build the specific service
+RUN cargo build --release -p lms-service
+
+# Final stage
+FROM debian:bookworm-slim
+RUN apt-get update && apt-get install -y libssl3 ca-certificates && rm -rf /var/lib/apt/lists/*
+
+WORKDIR /usr/local/bin
+COPY --from=builder /usr/src/app/target/release/lms-service .
+
+ENV RUST_LOG=info
+EXPOSE 3002
+
+CMD ["./lms-service"]

services/lms-service/migrations/20231219000001_enrollments.sql

@@ -0,0 +1,10 @@
+-- LMS specific schema
+CREATE TABLE enrollments (
+    id UUID PRIMARY KEY DEFAULT gen_random_uuid(),
+    user_id UUID NOT NULL,
+    course_id UUID NOT NULL, -- Referenced by ID from CMS service
+    enroled_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+);
+
+-- Note: In a real microservices scenario, courses might be synced from CMS or shared DB.
+-- Here we are using a shared DB for simplicity in this initial implementation.

services/lms-service/src/handlers.rs

@@ -0,0 +1,39 @@
+use axum::{
+    extract::State,
+    http::StatusCode,
+    Json,
+};
+use common::models::{Course, Enrollment};
+use sqlx::PgPool;
+use uuid::Uuid;
+
+pub async fn enroll_user(
+    State(pool): State<PgPool>,
+    Json(payload): Json<serde_json::Value>,
+) -> Result<Json<Enrollment>, StatusCode> {
+    let course_id_str = payload.get("course_id").and_then(|v| v.as_str()).ok_or(StatusCode::BAD_REQUEST)?;
+    let course_id = Uuid::parse_str(course_id_str).map_err(|_| StatusCode::BAD_REQUEST)?;
+    let user_id = Uuid::new_v4(); // Placeholder for actual auth
+
+    let enrollment = sqlx::query_as::<_, Enrollment>(
+        "INSERT INTO enrollments (user_id, course_id) VALUES ($1, $2) RETURNING *"
+    )
+    .bind(user_id)
+    .bind(course_id)
+    .fetch_one(&pool)
+    .await
+    .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+
+    Ok(Json(enrollment))
+}
+
+pub async fn get_course_catalog(
+    State(pool): State<PgPool>,
+) -> Result<Json<Vec<Course>>, StatusCode> {
+    let courses = sqlx::query_as::<_, Course>("SELECT * FROM courses")
+        .fetch_all(&pool)
+        .await
+        .map_err(|_| StatusCode::INTERNAL_SERVER_ERROR)?;
+
+    Ok(Json(courses))
+}

services/lms-service/src/main.rs

@@ -0,0 +1,33 @@
+mod handlers;
+
+use axum::{
+    routing::{get, post},
+    Router,
+};
+use sqlx::postgres::PgPoolOptions;
+use std::net::SocketAddr;
+use dotenvy::dotenv;
+use std::env;
+
+#[tokio::main]
+async fn main() {
+    dotenv().ok();
+    tracing_subscriber::fmt::init();
+
+    let db_url = env::var("DATABASE_URL").expect("DATABASE_URL must be set");
+    let pool = PgPoolOptions::new()
+        .max_connections(5)
+        .connect(&db_url)
+        .await
+        .expect("Failed to connect to database");
+
+    let app = Router::new()
+        .route("/catalog", get(handlers::get_course_catalog))
+        .route("/enroll", post(handlers::enroll_user))
+        .with_state(pool);
+
+    let addr = SocketAddr::from(([0, 0, 0, 0], 3002));
+    tracing::info!("LMS Service listening on {}", addr);
+    let listener = tokio::net::TcpListener::bind(addr).await.unwrap();
+    axum::serve(listener, app).await.unwrap();
+}