backend dot net

Author: PiyushInt

.github/workflows/ci.yml

@@ -1,75 +1,48 @@
 name: CI Pipeline
-
 on:
   push:
-    branches: [ "main" ]
+    branches: [main]
   pull_request:
-    branches: [ "main" ]
-
+    branches: [main]
 jobs:
-  build-and-test:
+  dotnet-api:
     runs-on: ubuntu-latest
-
     services:
       postgres:
         image: postgres:15
         env:
-          POSTGRES_USER: testuser
-          POSTGRES_PASSWORD: testpassword
-          POSTGRES_DB: testdb
-        ports:
-          - 5434:5432
+          POSTGRES_USER: lms_test
+          POSTGRES_PASSWORD: lms_test_password
+          POSTGRES_DB: postgres
+        ports: ["5436:5432"]
         options: >-
-          --health-cmd pg_isready
-          --health-interval 10s
-          --health-timeout 5s
-          --health-retries 5
-
+          --health-cmd "pg_isready -U lms_test -d postgres"
+          --health-interval 2s --health-timeout 5s --health-retries 20
     env:
-      DATABASE_URL: postgresql://testuser:testpassword@localhost:5434/testdb
-      JWT_SECRET: super_secret_dummy_jwt_key_that_is_at_least_32_bytes
-      NODE_ENV: test
-      CORS_ORIGIN: http://localhost:3000
-      RATE_LIMIT_LOGIN_MAX: 3
-      RATE_LIMIT_REGISTER_MAX: 5
-
+      LMS_TEST_ADMIN_CONNECTION: Host=127.0.0.1;Port=5436;Database=postgres;Username=lms_test;Password=lms_test_password
+    defaults:
+      run:
+        working-directory: backend-dotnet
     steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
+      - uses: actions/checkout@v4
+      - uses: actions/setup-dotnet@v4
         with:
-          node-version: '20'
-          cache: 'npm'
-          cache-dependency-path: backend/package-lock.json
-
-      - name: Install Dependencies
-        working-directory: ./backend
-        run: npm ci
-
-      - name: Generate Prisma Client
-        working-directory: ./backend
-        run: npx prisma generate
-
-      - name: Run Prisma Migrations
-        working-directory: ./backend
-        run: npx prisma migrate deploy
-
-      - name: Run Linter
-        working-directory: ./backend
-        run: npm run lint
-
-      - name: Run Tests
-        working-directory: ./backend
-        run: npm run test:ci
-
-      # Advisory only. Two high-severity findings (deepmerge-ts, mysql2) are
-      # transitive dependencies of the Prisma CLI. Neither is reachable at
-      # runtime — this project uses Postgres, so mysql2 never loads, and
-      # deepmerge-ts is build-time only. The only available fix is a breaking
-      # downgrade to Prisma 6. Revisit once Prisma updates its dependencies.
-      - name: Run Audit
-        working-directory: ./backend
-        continue-on-error: true
-        run: npm audit --audit-level=high --omit=dev
+          dotnet-version: 10.0.x
+      - run: dotnet restore Lms.Api.Tests/Lms.Api.Tests.csproj
+      - run: dotnet build Lms.Api.Tests/Lms.Api.Tests.csproj --no-restore --configuration Release
+      - run: dotnet test Lms.Api.Tests/Lms.Api.Tests.csproj --no-build --configuration Release
+      - run: dotnet publish Lms.Api/Lms.Api.csproj --no-restore --configuration Release --output publish
+  react:
+    runs-on: ubuntu-latest
+    defaults:
+      run:
+        working-directory: frontend
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '22'
+          cache: npm
+          cache-dependency-path: frontend/package-lock.json
+      - run: npm ci
+      - run: npm run build

.gitignore

@@ -9,3 +9,7 @@ database/*.sqlite
 task.md
 implementation_plan.md
 walkthrough.md
+**/bin/
+**/obj/
+**/TestResults/
+frontend/dist/

README.md

@@ -1,166 +1,58 @@
-# Mini LMS (Learning Management System) Backend
-
-[![CI Pipeline](https://github.com/PiyushInt/learning-management-system-fullstack/actions/workflows/ci.yml/badge.svg)](https://github.com/PiyushInt/learning-management-system-fullstack/actions/workflows/ci.yml)
-
-An advanced, resilient, and secure RESTful API for a Learning Management System designed to handle core educational workflows: course creation, student enrollment, assignment distribution, and grade-less submission tracking.
-
-## Overview
-This backend powers a multi-tenant learning environment where Teachers manage courses and assignments, and Students enroll in those courses and submit their work. It heavily emphasizes security boundaries, rate-limiting resilience, strict data consistency logic, and robust automated testing utilizing modern Node.js backend practices.
-
-## Tech Stack
-* **Language & Runtime:** Node.js (v20+), ES Modules
-* **Framework:** Express.js (v5)
-* **Database & ORM:** PostgreSQL (v15), Prisma ORM
-* **Security & Hardening:** Helmet, express-rate-limit, CORS, bcrypt, Joi
-* **Observability:** Winston (Structured logging, Recursive redaction)
-* **Testing:** Jest, Supertest
-* **CI/CD:** GitHub Actions (Clean-clone DB migration tests, Linting, Audit)
-
-## Architecture
-
-```mermaid
-graph TD
-    Client[Client App / Postman] --> |HTTP / JSON| API[Express API Gateway]
-    
-    subgraph Express Backend
-        API --> RateLimit[Rate Limiter]
-        RateLimit --> Auth[Auth Middleware]
-        Auth --> Validation[Joi Boundary Validation]
-        Validation --> Controllers[Controllers]
-        Controllers --> CoreAuth[Core Authorization]
-        CoreAuth --> Services[Domain Services]
-    end
-    
-    Services --> |Prisma Client| DB[(PostgreSQL)]
-    
-    subgraph Observability
-        Controllers -.-> Logger[Winston Logger]
-        Services -.-> Logger
-        Logger -.-> |Redacts PII/Tokens| LogOutput[Stdout/JSON]
-    end
-```
+# Learning Management System
 
-## Project Structure
-```text
-backend/
-├── src/
-│   ├── app.js               # Express app configuration & hardening
-│   ├── server.js            # Entry point & Graceful shutdown
-│   ├── config/              # Centralized environment variable parsing
-│   ├── controllers/         # HTTP request/response handlers
-│   ├── core/                # Core domain logic (authorization.js)
-│   ├── middlewares/         # Joi validation, error handling, logging, JWT auth
-│   ├── routes/              # Route definitions
-│   ├── services/            # Business logic and Prisma DB interactions
-│   ├── utils/               # Helpers (e.g., JWT signing/verification)
-│   └── validations/         # Joi schema definitions
-├── tests/                   # Jest integration test suite & fixtures
-├── prisma/                  # Prisma schema and migrations
-├── .env.example             # Template for environment variables
-├── package.json             # NPM dependencies & scripts
-└── eslint.config.js         # Linter configuration
-.github/workflows/           # CI/CD pipelines
-```
+A React application backed by a C# ASP.NET Core API and PostgreSQL. Teachers create courses and assignments; students enroll and submit work.
 
-## Getting Started
+## Stack
 
-### Prerequisites
-* Node.js (v20+)
-* Docker & Docker Compose (for the local test database)
-* PostgreSQL (if running locally without Docker)
+- Frontend: React, Vite, Redux Toolkit, Axios
+- Backend: .NET 10, ASP.NET Core controllers, Entity Framework Core, Npgsql
+- Database: PostgreSQL 15+ (the existing Prisma table structure is preserved)
+- Authentication: bcrypt passwords and HS256 JWTs with teacher/student authorization
+- Tests: xUnit integration tests against isolated PostgreSQL databases
 
-### Environment Setup
-Create a `.env` file in the `backend/` directory:
+## Structure
 
-```env
-PORT=3000
-DATABASE_URL="postgresql://user:password@localhost:5432/dbname"
-JWT_SECRET="replace_with_a_secure_random_string"
-JWT_EXPIRES_IN="1d"
+```text
+frontend/                 Existing React application
+backend-dotnet/Lms.Api/    C# API, entities, services, EF migrations
+backend-dotnet/Lms.Api.Tests/  API and database adoption tests
+backend/                  Legacy Express API and original Prisma migrations
+start_app.sh              Starts React and .NET; supports Express rollback
 ```
-*(Note: A test database configuration is automatically managed via the `run-tests.sh` script when running `npm test`.)*
 
-### Installation & Execution
+## Run with a fresh local database
+
+Install .NET 10 SDK, Node.js 22.12+ and Docker Compose (or use an existing PostgreSQL server).
+
 ```bash
-cd backend/
+cp backend-dotnet/.env.example backend-dotnet/.env
+# Edit backend-dotnet/.env and replace the JWT secret.
+docker compose -f backend-dotnet/compose.yaml up -d --wait db
+bash backend-dotnet/run.sh --migrate
+bash start_app.sh
+```
 
-# Install dependencies using ci for exact lockfile match
-npm ci
+React uses port 5173 and proxies `/api` to the .NET API at port 5050. Schema migrations are explicit commands; starting the API never recreates tables or applies migrations.
 
-# Generate the Prisma Client
-npm run prisma:generate
+**Existing LMS database:** follow the backup, inspection, and adoption procedure in [the migration guide](backend-dotnet/README.md#existing-prisma-database). Do not initialize or reset it as a fresh database.
 
-# Apply database migrations
-npm run prisma:migrate
+## Test
 
-# Start the server (Development)
-npm run dev
+```bash
+bash backend-dotnet/run-tests.sh
+cd frontend
+npm ci
+npm run build
 ```
 
-## API Reference
-
-### Authentication
-| Method | Endpoint | Description | Auth Required |
-| :--- | :--- | :--- | :--- |
-| `POST` | `/auth/register` | Register a new user (Teacher/Student) | No |
-| `POST` | `/auth/login` | Authenticate and receive a JWT | No |
-
-### Courses & Enrollments
-| Method | Endpoint | Description | Auth Required (Role) |
-| :--- | :--- | :--- | :--- |
-| `GET`  | `/courses` | List all available courses | No |
-| `POST` | `/courses` | Create a new course | Yes (TEACHER) |
-| `GET`  | `/courses/enrolled` | List courses the student is enrolled in | Yes (STUDENT) |
-| `POST` | `/courses/:id/enroll` | Enroll the current student into a course | Yes (STUDENT) |
-| `GET`  | `/courses/:id/assignments` | List assignments for a course | Yes (Enrolled STUDENT / Owning TEACHER) |
-| `POST` | `/courses/:id/assignments` | Create a new assignment for a course | Yes (Owning TEACHER) |
-
-### Assignments & Submissions
-| Method | Endpoint | Description | Auth Required (Role) |
-| :--- | :--- | :--- | :--- |
-| `POST` | `/assignments/:id/submit` | Submit work for an assignment | Yes (Enrolled STUDENT) |
-| `GET`  | `/assignments/:id/submissions` | List all submissions for an assignment | Yes (Owning TEACHER) |
-
-## Security
-
-This system implements a strict defense-in-depth security architecture with a clear separation of concerns:
-
-1. **Role Checks vs. Ownership Checks**: 
-   - **Role Checks** are performed early at the HTTP boundary via the JWT middleware (e.g., verifying a user is a `TEACHER` before allowing access to course creation).
-   - **Ownership & Domain Guards** live deeper in the stack within `src/core/authorization.js`. This module strictly handles data-level authorization, ensuring that a standard Prisma query always verifies a Teacher actually owns the course they are modifying, or a Student is genuinely enrolled in the course they are interacting with.
-
-2. **Route Coverage Matrix**:
-
-| Route | Role Check (Middleware) | Ownership / Domain Check (`authorization.js`) |
-| :--- | :--- | :--- |
-| `/auth/register` | None | None |
-| `/auth/login` | None | None |
-| `GET /courses` | None | None |
-| `POST /courses` | `TEACHER` | None |
-| `GET /courses/enrolled` | `STUDENT` | None |
-| `POST /courses/:id/enroll` | `STUDENT` | Implicit (creates enrollment) |
-| `GET /courses/:id/assignments` | `STUDENT` or `TEACHER` | `assertEnrolled` (Student) OR `assertOwnsCourse` (Teacher) |
-| `POST /courses/:id/assignments`| `TEACHER` | `assertOwnsCourse` |
-| `POST /assignments/:id/submit` | `STUDENT` | `assertEnrolled` (via Course) |
-| `GET /assignments/:id/submissions`| `TEACHER`| `assertOwnsCourse` (via Course) |
-
-3. **Strict Boundary Validation**: All incoming requests pass through a global `validateBody` middleware using strict Joi schemas, dropping malformed payloads before they reach business logic.
-4. **Recursive Log Redaction**: The Winston logger utilizes a recursive object traversal function to guarantee PII (`password`, `token`, etc.) is redacted (`[REDACTED]`), regardless of nesting depth.
-
-## Testing
-The repository maintains strict integration test coverage spanning the full API boundary, database constraint validation, rate limiting, and log redaction.
+Tests use disposable, uniquely named PostgreSQL databases. An external local test server can be selected using `LMS_TEST_ADMIN_CONNECTION`.
+
+## Roll back to Express
 
 ```bash
-# Run the full test suite (automatically spins up a clean Postgres container on port 5434)
-npm test
+LMS_BACKEND=node bash start_app.sh
 ```
 
-## Design Decisions
-- **Hard Delete cascades**: `onDelete: Cascade` rules were implemented strictly across the schema. A course serves as a container; deleting a course destroys its assignments and submissions.
-- **UUIDs and API Coercion**: A dedicated integer coercion middleware shields the database from Prisma's `NaN` panics.
-- **Graceful Shutdown & Resilience**: The application leverages `SIGTERM`/`SIGINT` traps and explicitly delays startup until the database emits a successful connection ping.
-- **Audit Exception (`deepmerge-ts`, `mysql2`)**: The `npm audit` step currently returns advisory warnings for high-severity findings related to `deepmerge-ts` and `mysql2`. These are transitive dependencies of the Prisma CLI. Since this project strictly uses PostgreSQL, the `mysql2` vulnerability is unreachable at runtime. Resolving these warnings would require a breaking downgrade of Prisma. The audit step remains advisory (non-blocking) as no runtime risk is present.
+This selects the old API on port 3000 and changes the development proxy. Retain the same database and JWT secret during the compatibility window; do not run Prisma migrations after transferring migration ownership to EF Core.
 
-## Limitations
-- **No Frontend**: This repository is strictly a backend API. The GitHub Actions CI pipeline verifies backend linting, database migrations from scratch, and integration tests, but intentionally does not build or assert UI artifacts.
-- **In-Memory Rate Limiting**: The `express-rate-limit` configuration uses the default memory store. In a multi-node production deployment, this should be migrated to a Redis store.
+See [backend setup, API contract, and deployment](backend-dotnet/README.md) for details.

backend-dotnet/.config/dotnet-tools.json

@@ -0,0 +1,10 @@
+{
+  "version": 1,
+  "isRoot": true,
+  "tools": {
+    "dotnet-ef": {
+      "version": "10.0.12",
+      "commands": ["dotnet-ef"]
+    }
+  }
+}

backend-dotnet/.env.example

@@ -0,0 +1,10 @@
+ASPNETCORE_ENVIRONMENT=Development
+ASPNETCORE_URLS=http://localhost:5050
+DATABASE_URL=postgresql://lms:lms_local_password@localhost:5435/lms
+JWT_SECRET=replace_with_a_random_secret_at_least_32_bytes_long
+JWT_EXPIRES_IN=1d
+CORS_ORIGIN=http://localhost:5173
+RATE_LIMIT_LOGIN_MAX=5
+RATE_LIMIT_REGISTER_MAX=10
+# Set only when deployed behind a known reverse proxy (comma-separated IPs):
+# TRUSTED_PROXIES=127.0.0.1