feat(database): add roles, permissions, users, modules, and related tables

Add tables for role-based access control and academic entities.
Includes modules, UEs, notes, and adjustments.
Update students and mobility tables to reference new primary keys.
This enables richer data modeling for the application.

.gitea/workflows/deploy.yml

@@ -6,26 +6,9 @@ on:
       - main
 
 jobs:
-  check-code:
-    name: "Check Deno code"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: denoland/setup-deno@v2
-        with:
-          deno-version: v2.x
-
-      - name: Check formatting
-        run: deno fmt --check
-
-      - name: Check linting
-        run: deno lint
-
   deploy:
     name: "Build Docker image"
     runs-on: ubuntu-latest
-    needs: check-code
     steps:
       - name: Login to Docker Hub
         uses: docker/login-action@v3

.gitea/workflows/lint.yml

@@ -4,10 +4,6 @@ on:
   pull_request:
     branches:
       - main
-      - develop
-  push:
-    branches:
-      - develop
 
 permissions:
   contents: read

.gitea/workflows/test.yml

@@ -1,70 +0,0 @@
-name: "Tests"
-
-on:
-  pull_request:
-    branches:
-      - main
-      - develop
-  push:
-    branches:
-      - develop
-
-jobs:
-  unit:
-    name: "Unit tests"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: denoland/setup-deno@v2
-        with:
-          deno-version: v2.x
-
-      - name: Install dependencies
-        run: deno install
-
-      - name: Run unit tests
-        run: deno task test:unit
-
-  integration:
-    name: "Integration tests"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - uses: actions/setup-node@v4
-        with:
-          node-version: "20"
-
-      - uses: denoland/setup-deno@v2
-        with:
-          deno-version: v2.x
-
-      - name: Start postgres
-        run: |
-          sudo apt-get update -qq && sudo apt-get install -y -qq postgresql > /dev/null
-          PG_VER=$(ls /etc/postgresql/)
-          sudo sed -i "s/^#*listen_addresses\s*=.*/listen_addresses = '127.0.0.1'/" /etc/postgresql/$PG_VER/main/postgresql.conf
-          echo "host all all 127.0.0.1/32 md5" | sudo tee -a /etc/postgresql/$PG_VER/main/pg_hba.conf
-          sudo pg_ctlcluster $PG_VER main restart
-          until sudo -u postgres pg_isready -h 127.0.0.1; do sleep 1; done
-          sudo -u postgres psql -c "CREATE USER test WITH PASSWORD 'test';"
-          sudo -u postgres psql -c "CREATE DATABASE polympr_test OWNER test;"
-          sudo -u postgres psql -d polympr_test -c "GRANT ALL ON SCHEMA public TO test;"
-
-      - name: Apply migrations
-        run: |
-          sed 's/--> statement-breakpoint/;/g' databases/migrations/0000_square_jetstream.sql | \
-            PGPASSWORD=test psql -h 127.0.0.1 -U test -d polympr_test
-
-      - name: Install dependencies
-        run: npm install --ignore-scripts && deno install
-
-      - name: Run integration tests
-        env:
-          POSTGRES_HOST: 127.0.0.1
-          POSTGRES_PORT: 5432
-          POSTGRES_USER: test
-          POSTGRES_PASS: test
-          POSTGRES_DB: polympr_test
-        run: deno task test:integration

CLAUDE.md

@@ -1,338 +0,0 @@
-# PolyMPR - Claude Code Context
-
-## 📋 Project Overview
-
-**PolyMPR** (Poly Management Platform for Resources) is a modular HR management
-system built with **Deno + Fresh** framework. It's designed to help
-organizations manage HR, student records, notes, mobility programs, and
-role-based administration.
-
-### Stack
-
-- **Runtime**: Deno
-- **Framework**: Fresh (edge-ready web framework)
-- **Database**: PostgreSQL with Drizzle ORM
-- **Frontend**: Preact with signals
-- **Authentication**: JWT-based via cookies
-- **Testing**: Deno test framework with HappyDOM for DOM testing
-
-### Current Status
-
-🚧 **In Progress** - Application is far from complete. The schema below is the
-**final/definitive schema** that should guide all development.
-
----
-
-## 🏗️ Architecture
-
-### Module Structure
-
-The application uses a **modulith architecture** with the following modules:
-
-```
-routes/(apps)/
-├── students/      - Student management & promotions
-├── notes/         - Grade management & academic records
-├── mobility/      - Mobility programs & exchanges
-└── admin/         - Role & permission management
-```
-
-### Key Directories
-
-- `/routes` - Fresh routes and components
-- `/databases` - Database connection, schema, and migrations
-- `/defaults` - Interfaces and shared types
-- `/tests` - Unit, integration, and E2E tests
-- `/static` - Public assets
-
-### Authentication Flow
-
-1. User authenticates via CAS (Polytech)
-2. JWT token stored in `sessionToken` cookie
-3. Middleware validates token on each request
-4. Public routes: `/`, `/login`, `/logout`, `/about`, `/contact`
-5. All other routes require authentication
-
----
-
-## 📊 Database Schema (Final/Definitive)
-
-```mermaid
-erDiagram
-  USER {
-    string id PK
-    string nom
-    string prenom
-    int idRole FK
-  }
-  ROLE {
-    int id PK
-    string nom
-  }
-  PERMISSION {
-    int id PK
-    string nom
-  }
-  ROLE_PERMISSION {
-    int idRole PK,FK
-    int idPermission PK,FK
-  }
-  STUDENT {
-    int numEtud PK
-    string nom
-    string prenom
-    string idPromo FK
-  }
-  PROMOTION {
-    string idPromo PK
-    string annee
-  }
-  MODULE {
-    string id PK
-    string nom
-  }
-  ENSEIGNEMENT {
-    string idProf PK,FK
-    string idModule PK,FK
-    string idPromo PK,FK
-  }
-  UE {
-    int id PK
-    string nom
-  }
-  UE_MODULE {
-    string idModule PK,FK
-    int idUE PK,FK
-    string idPromo PK,FK
-    float coeff
-  }
-  NOTE {
-    int numEtud PK,FK
-    string idModule PK,FK
-    float note
-  }
-  AJUSTEMENT {
-    int numEtud PK,FK
-    int idUE PK,FK
-    float valeur
-  }
-
-  USER }o--|| ROLE : "a"
-  ROLE_PERMISSION }o--|| ROLE : "accorde"
-  ROLE_PERMISSION }o--|| PERMISSION : "inclut"
-  ENSEIGNEMENT }o--|| USER : "réalisé par"
-  ENSEIGNEMENT }o--|| MODULE : "porte sur"
-  ENSEIGNEMENT }o--|| PROMOTION : "concerne"
-  STUDENT }o--|| PROMOTION : "appartient à"
-  UE_MODULE }o--|| MODULE : "associe"
-  UE_MODULE }o--|| UE : "appartient à"
-  UE_MODULE }o--|| PROMOTION : "pour"
-  NOTE }o--|| STUDENT : "reçoit"
-  NOTE }o--|| MODULE : "dans"
-  AJUSTEMENT }o--|| STUDENT : "concerne"
-  AJUSTEMENT }o--|| UE : "dans"
-```
-
-### Current Schema (Incomplete)
-
-The current Drizzle ORM schema in `/databases/schema.ts` only implements:
-
-- `promotions`
-- `students`
-- `mobility`
-
-**Migration needed**: Update schema to match the final ER diagram above.
-
----
-
-## 🎯 Open Issues (69 total)
-
-### UI Pages
-
-**Catalog**
-
-- 📋 UI - Page Catalogue d'applications (#71)
-
-**Components**
-
-- 🎨 UI (composant) - Popup Résultats d'import (#75)
-
-**Students**
-
-- 📋 UI - Admin – Liste des élèves (#79)
-- 📋 UI - Admin – Gestion des promotions (#80)
-- 📋 UI - Admin – Import xlsx élèves (#81)
-- 📋 UI - Admin – Édition d'un élève (#82)
-
-**Notes**
-
-- 📋 UI - Page Élève – Mes Notes (#72)
-- 📋 UI - Admin – Consulter les notes (#73)
-- 📋 UI - Admin – Importer des notes (.xlsx) (#74)
-- 📋 UI - Admin – Édition notes d'un élève (#76)
-- 📋 UI - Admin – Récap notes élève / semestre (#77)
-- 📋 UI - Admin – Gestion des UEs (#78)
-
-**Administration**
-
-- 📋 UI - Gestion des utilisateurs (#83)
-- 📋 UI - Gestion des rôles (#84)
-- 📋 UI - Permissions d'un rôle (#85)
-- 📋 UI - Vue des permissions (#86)
-- 📋 UI - Gestion des modules (#87)
-- 📋 UI - Enseignements (Assignations) (#88)
-
----
-
-### API Endpoints
-
-**Students API**
-
-- 📋 GET `/students` (#7)
-- 📋 POST `/students` (#8)
-- 📋 POST `/students/import-csv` (#9)
-- 📋 GET `/students/{numEtud}` (#10)
-- 📋 PUT `/students/{numEtud}` (#11)
-- 📋 DELETE `/students/{numEtud}` (#12)
-- 📋 GET `/promotions` (#13)
-- 📋 POST `/promotions` (#14)
-- 📋 GET `/promotions/{idPromo}` (#15)
-- 📋 PUT `/promotions/{idPromo}` (#16)
-- 📋 DELETE `/promotions/{idPromo}` (#17)
-
-**Administration API - Modules & Enseignements**
-
-- 📋 GET `/modules` (#23)
-- 📋 POST `/modules` (#24)
-- 📋 GET `/modules/{idModule}` (#25)
-- 📋 PUT `/modules/{idModule}` (#26)
-- 📋 DELETE `/modules/{idModule}` (#27)
-- 📋 POST `/enseignements` (#29)
-- 📋 GET `/enseignements/{idProf}/{idModule}/{idPromo}` (#30)
-- 📋 DELETE `/enseignements/{idProf}/{idModule}/{idPromo}` (#31)
-
-**Notes API - UEs & UE-Modules**
-
-- 📋 GET `/ues` (#32)
-- 📋 POST `/ues` (#33)
-- 📋 GET `/ues/{idUE}` (#34)
-- 📋 PUT `/ues/{idUE}` (#35)
-- 📋 DELETE `/ues/{idUE}` (#36)
-- 📋 GET `/ue-modules` (#37)
-- 📋 POST `/ue-modules` (#38)
-- 📋 GET `/ue-modules/{idModule}/{idUE}/{idPromo}` (#39)
-- 📋 PUT `/ue-modules/{idModule}/{idUE}/{idPromo}` (#40)
-- 📋 DELETE `/ue-modules/{idModule}/{idUE}/{idPromo}` (#41)
-
-**Notes API - Notes & Ajustements**
-
-- 📋 GET `/notes` (#42)
-- 📋 POST `/notes` (#43)
-- 📋 POST `/notes/import-xlsx` (#44)
-- 📋 GET `/notes/{numEtud}/{idModule}` (#45)
-- 📋 PUT `/notes/{numEtud}/{idModule}` (#46)
-- 📋 DELETE `/notes/{numEtud}/{idModule}` (#47)
-- 📋 GET `/ajustements` (#48)
-- 📋 POST `/ajustements` (#49)
-- 📋 GET `/ajustements/{numEtud}/{idUE}` (#50)
-- 📋 PUT `/ajustements/{numEtud}/{idUE}` (#51)
-- 📋 DELETE `/ajustements/{numEtud}/{idUE}` (#52)
-
-**Administration API - Users, Roles & Permissions**
-
-- 📋 GET `/users` (#60)
-- 📋 POST `/users` (#61)
-- 📋 GET `/users/{id}` (#62)
-- 📋 PUT `/users/{id}` (#63)
-- 📋 DELETE `/users/{id}` (#64)
-- 📋 GET `/roles` (#65)
-- 📋 POST `/roles` (#66)
-- 📋 GET `/roles/{idRole}` (#67)
-- 📋 PUT `/roles/{idRole}` (#68)
-- 📋 DELETE `/roles/{idRole}` (#69)
-- 📋 GET `/permissions` (#70)
-
----
-
-## 🎨 Design Reference
-
-**Figma Prototype**:
-https://www.figma.com/design/La79bsUsWnJCtMsrrt2zGd/Prototype?node-id=0-1
-
-This is the **final design specification** for the UI. All UI implementations
-should follow this design.
-
----
-
-## 🚀 Development Guidelines
-
-### Getting Started
-
-```bash
-# Run tests
-deno task test
-
-# Start development server
-deno task start
-
-# Build for production
-deno task build
-
-# Format & lint
-deno task check
-```
-
-### Git Workflow
-
-1. Create branch: `git checkout -b PMPR-{ISSUE_ID}`
-2. Implement changes
-3. Run tests and linting
-4. Submit PR
-
-### Code Style
-
-- Format: Follow Deno defaults (enforced via `deno fmt`)
-- Linting: Fresh recommended rules
-- TypeScript strict mode enabled
-- Use Drizzle ORM for database operations
-
-### Testing
-
-- Write unit tests for business logic
-- Integration tests for API endpoints
-- E2E tests with HappyDOM for UI interactions
-- Mock database with provided helpers
-
----
-
-## 📦 Key Dependencies
-
-- **fresh@1.7.3** - Web framework
-- **drizzle-orm@0.45.2** - ORM
-- **pg@8.20.0** - PostgreSQL driver
-- **@popov/jwt@1.0.1** - JWT utilities
-- **preact@10.22.0** - UI library
-- **happy-dom@16.0.0** - DOM testing
-
----
-
-## 🔗 Related Resources
-
-- **Repository**: https://git.polytech.djalim.fr/djalim/PolyMPR
-- **Issue Tracker**: Gitea (via `tea` CLI)
-- **Wiki**: Check CONTRIBUTING.md for dev setup
-- **Database**: PostgreSQL (configured in `.env`)
-
----
-
-## 💡 Important Notes
-
-1. **Current Limitation**: The database schema in `/databases/schema.ts` does
-   NOT match the final ER diagram. This is a priority migration task.
-2. **Design System**: Follow the Figma prototype for all UI work.
-3. **Module Pattern**: Each module should follow the same pattern: routes, API
-   endpoints, components, and tests.
-4. **Permissions**: All admin operations should respect the ROLE_PERMISSION
-   system.
-5. **Fresh Conventions**: Routes use Fresh's file-based routing convention
-   (e.g., `routes/path/index.tsx`).

bugs.md

@@ -1,158 +0,0 @@
-# Bug Report — PolyMPR
-
-> Généré le 2026-04-23
-
----
-
-## 🔴 Critique
-
-### #1 — Schema mismatch : module mobility entièrement cassé
-
-**Fichier** : `routes/(apps)/mobility/api/insert_mobility.ts`
-
-Références à des colonnes inexistantes dans le schéma Drizzle :
-
-| Utilisé dans le code   | Colonne réelle     |
-| ---------------------- | ------------------ |
-| `students.userId`      | `students.numEtud` |
-| `students.firstName`   | `students.nom`     |
-| `students.lastName`    | `students.prenom`  |
-| `students.promotionId` | `students.idPromo` |
-| `promotions.endyear`   | `promotions.annee` |
-| `promotions.current`   | _(n'existe pas)_   |
-
-Le module crashe à l'exécution. À corriger en alignant les noms de colonnes avec
-le schéma.
-
----
-
-### #2 — Auth manquante sur de nombreux endpoints
-
-Les endpoints suivants n'ont aucune vérification `eduPersonPrimaryAffiliation` :
-
-- `routes/(apps)/notes/api/notes.ts` (GET, POST)
-- `routes/(apps)/notes/api/ue-modules.ts` (GET, POST)
-- `routes/(apps)/notes/api/ues.ts` (GET, POST)
-- `routes/(apps)/notes/api/ues/[idUE].ts` (GET, PUT, DELETE)
-- `routes/(apps)/admin/api/users.ts` (GET, POST)
-- `routes/(apps)/admin/api/users/[id].ts` (GET, PUT, DELETE)
-- `routes/(apps)/admin/api/modules/[idModule].ts` (GET, PUT, DELETE)
-- `routes/(apps)/admin/api/roles.ts` (GET, POST)
-- `routes/(apps)/admin/api/roles/[idRole].ts` (GET, PUT, DELETE)
-- `routes/(apps)/admin/api/permissions.ts` (GET)
-- `routes/(apps)/mobility/api/insert_mobility.ts`
-
-Tous ces endpoints exposent des données sensibles sans vérifier les permissions.
-
----
-
-## 🟠 Haut
-
-### #3 — Bug Drizzle ORM : `.where()` avec plusieurs `eq()` sans `and()`
-
-**Fichier** : `routes/(apps)/notes/api/ajustements/[numEtud]/[idUE].ts` — lignes
-34, 72, 100
-
-`.where()` n'accepte qu'un seul argument. Passer plusieurs `eq()` séparés par
-des virgules ne génère pas le SQL attendu (seule la première condition est prise
-en compte).
-
-```ts
-// ❌ Incorrect
-.where(eq(ajustements.numEtud, numEtud), eq(ajustements.idUE, idUE))
-
-// ✅ Correct
-.where(and(eq(ajustements.numEtud, numEtud), eq(ajustements.idUE, idUE)))
-```
-
----
-
-### #4 — Bug Drizzle ORM : `.where()` à 3 conditions sans `and()`
-
-**Fichier** :
-`routes/(apps)/notes/api/ue-modules/[idModule]/[idUE]/[idPromo].ts` — handler
-GET (~ligne 41)
-
-Même problème que #3, mais avec 3 conditions. Les handlers PUT et DELETE ont
-déjà `and()`, seul le GET est affecté.
-
-```ts
-// ❌ Incorrect
-.where(
-  eq(ueModules.idModule, idModule),
-  eq(ueModules.idUE, idUE),
-  eq(ueModules.idPromo, idPromo),
-)
-
-// ✅ Correct
-.where(
-  and(
-    eq(ueModules.idModule, idModule),
-    eq(ueModules.idUE, idUE),
-    eq(ueModules.idPromo, idPromo),
-  ),
-)
-```
-
----
-
-## 🟡 Moyen
-
-### #5 — `and()` passé avec des valeurs `undefined`
-
-**Fichier** : `routes/(apps)/notes/api/ue-modules.ts`
-
-```ts
-and(
-  idPromo ? eq(ueModules.idPromo, idPromo) : undefined,
-  idUE ? eq(ueModules.idUE, idUE) : undefined,
-);
-```
-
-Drizzle tolère les `undefined` dans `and()` dans certaines versions, mais ce
-n'est pas garanti. Mieux vaut construire les conditions dynamiquement avant de
-les passer.
-
----
-
-### #6 — Validation `!numEtud` rejette faussement `0`
-
-**Fichier** : `routes/(apps)/notes/api/notes.ts` — handler POST
-
-```ts
-// ❌ Rejette numEtud = 0
-if (note === undefined || !numEtud || !idModule)
-
-// ✅ Correct
-if (note === undefined || numEtud === undefined || numEtud === null || !idModule)
-```
-
----
-
-### #7 — `Number(idRole)` sans vérification `isNaN`
-
-**Fichier** : `routes/(apps)/admin/api/users.ts`
-
-Si `idRole` est une chaîne non numérique, `Number()` retourne `NaN` ce qui
-provoque une erreur SQL.
-
-```ts
-// ❌ Pas de vérification
-const rows = idRole
-  ? await db.select().from(users).where(eq(users.idRole, Number(idRole)))
-  : await db.select().from(users);
-
-// ✅ Valider avant usage
-const role = Number(idRole);
-if (isNaN(role)) return new Response(..., { status: 400 });
-```
-
----
-
-### #8 — Réponses d'erreur en texte brut au lieu de JSON
-
-**Fichier** : `routes/(apps)/notes/api/notes.ts`
-
-Certaines réponses d'erreur retournent une string sans
-`content-type: application/json`, incohérent avec le reste de l'API qui retourne
-`{ error: "..." }`.

compose.yml

@@ -22,3 +22,5 @@ services:
       replicas: 1
       placement:
         constraints: [node.role == manager]
+
+

databases/db.ts

@@ -1,5 +1,5 @@
-import { drizzle } from "npm:drizzle-orm@0.45.2/node-postgres";
+import { drizzle } from "npm:drizzle-orm/node-postgres";
-import pg from "npm:pg@8.20.0";
+import pg from "npm:pg";
 
 const { Pool } = pg;
 

databases/migrations/0000_square_jetstream.sql

@@ -1,100 +0,0 @@
-CREATE TABLE "ajustements" (
-	"numEtud" integer NOT NULL,
-	"idUE" integer NOT NULL,
-	"valeur" double precision NOT NULL,
-	CONSTRAINT "ajustements_numEtud_idUE_pk" PRIMARY KEY("numEtud","idUE")
-);
---> statement-breakpoint
-CREATE TABLE "enseignements" (
-	"idProf" text NOT NULL,
-	"idModule" text NOT NULL,
-	"idPromo" text NOT NULL,
-	CONSTRAINT "enseignements_idProf_idModule_idPromo_pk" PRIMARY KEY("idProf","idModule","idPromo")
-);
---> statement-breakpoint
-CREATE TABLE "mobility" (
-	"id" serial PRIMARY KEY NOT NULL,
-	"studentId" integer,
-	"startDate" date,
-	"endDate" date,
-	"weeksCount" integer,
-	"destinationCountry" text,
-	"destinationName" text,
-	"mobilityStatus" text DEFAULT 'N/A'
-);
---> statement-breakpoint
-CREATE TABLE "modules" (
-	"id" text PRIMARY KEY NOT NULL,
-	"nom" text NOT NULL
-);
---> statement-breakpoint
-CREATE TABLE "notes" (
-	"numEtud" integer NOT NULL,
-	"idModule" text NOT NULL,
-	"note" double precision NOT NULL,
-	CONSTRAINT "notes_numEtud_idModule_pk" PRIMARY KEY("numEtud","idModule")
-);
---> statement-breakpoint
-CREATE TABLE "permissions" (
-	"id" text PRIMARY KEY NOT NULL,
-	"nom" text NOT NULL
-);
---> statement-breakpoint
-CREATE TABLE "promotions" (
-	"idPromo" text PRIMARY KEY NOT NULL,
-	"annee" text
-);
---> statement-breakpoint
-CREATE TABLE "role_permissions" (
-	"idRole" integer NOT NULL,
-	"idPermission" text NOT NULL,
-	CONSTRAINT "role_permissions_idRole_idPermission_pk" PRIMARY KEY("idRole","idPermission")
-);
---> statement-breakpoint
-CREATE TABLE "roles" (
-	"id" serial PRIMARY KEY NOT NULL,
-	"nom" text NOT NULL
-);
---> statement-breakpoint
-CREATE TABLE "students" (
-	"numEtud" serial PRIMARY KEY NOT NULL,
-	"nom" text NOT NULL,
-	"prenom" text NOT NULL,
-	"idPromo" text
-);
---> statement-breakpoint
-CREATE TABLE "ue_modules" (
-	"idModule" text NOT NULL,
-	"idUE" integer NOT NULL,
-	"idPromo" text NOT NULL,
-	"coeff" double precision NOT NULL,
-	CONSTRAINT "ue_modules_idModule_idUE_idPromo_pk" PRIMARY KEY("idModule","idUE","idPromo")
-);
---> statement-breakpoint
-CREATE TABLE "ues" (
-	"id" serial PRIMARY KEY NOT NULL,
-	"nom" text NOT NULL
-);
---> statement-breakpoint
-CREATE TABLE "users" (
-	"id" text PRIMARY KEY NOT NULL,
-	"nom" text NOT NULL,
-	"prenom" text NOT NULL,
-	"idRole" integer
-);
---> statement-breakpoint
-ALTER TABLE "ajustements" ADD CONSTRAINT "ajustements_numEtud_students_numEtud_fk" FOREIGN KEY ("numEtud") REFERENCES "public"."students"("numEtud") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "ajustements" ADD CONSTRAINT "ajustements_idUE_ues_id_fk" FOREIGN KEY ("idUE") REFERENCES "public"."ues"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "enseignements" ADD CONSTRAINT "enseignements_idProf_users_id_fk" FOREIGN KEY ("idProf") REFERENCES "public"."users"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "enseignements" ADD CONSTRAINT "enseignements_idModule_modules_id_fk" FOREIGN KEY ("idModule") REFERENCES "public"."modules"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "enseignements" ADD CONSTRAINT "enseignements_idPromo_promotions_idPromo_fk" FOREIGN KEY ("idPromo") REFERENCES "public"."promotions"("idPromo") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "mobility" ADD CONSTRAINT "mobility_studentId_students_numEtud_fk" FOREIGN KEY ("studentId") REFERENCES "public"."students"("numEtud") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "notes" ADD CONSTRAINT "notes_numEtud_students_numEtud_fk" FOREIGN KEY ("numEtud") REFERENCES "public"."students"("numEtud") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "notes" ADD CONSTRAINT "notes_idModule_modules_id_fk" FOREIGN KEY ("idModule") REFERENCES "public"."modules"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "role_permissions" ADD CONSTRAINT "role_permissions_idRole_roles_id_fk" FOREIGN KEY ("idRole") REFERENCES "public"."roles"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "role_permissions" ADD CONSTRAINT "role_permissions_idPermission_permissions_id_fk" FOREIGN KEY ("idPermission") REFERENCES "public"."permissions"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "students" ADD CONSTRAINT "students_idPromo_promotions_idPromo_fk" FOREIGN KEY ("idPromo") REFERENCES "public"."promotions"("idPromo") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "ue_modules" ADD CONSTRAINT "ue_modules_idModule_modules_id_fk" FOREIGN KEY ("idModule") REFERENCES "public"."modules"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "ue_modules" ADD CONSTRAINT "ue_modules_idUE_ues_id_fk" FOREIGN KEY ("idUE") REFERENCES "public"."ues"("id") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "ue_modules" ADD CONSTRAINT "ue_modules_idPromo_promotions_idPromo_fk" FOREIGN KEY ("idPromo") REFERENCES "public"."promotions"("idPromo") ON DELETE no action ON UPDATE no action;--> statement-breakpoint
-ALTER TABLE "users" ADD CONSTRAINT "users_idRole_roles_id_fk" FOREIGN KEY ("idRole") REFERENCES "public"."roles"("id") ON DELETE no action ON UPDATE no action;

databases/migrations/meta/0000_snapshot.json

@@ -1,680 +0,0 @@
-{
-  "id": "bd317b68-1c46-4e83-b4d3-a14f68751afb",
-  "prevId": "00000000-0000-0000-0000-000000000000",
-  "version": "7",
-  "dialect": "postgresql",
-  "tables": {
-    "public.ajustements": {
-      "name": "ajustements",
-      "schema": "",
-      "columns": {
-        "numEtud": {
-          "name": "numEtud",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "idUE": {
-          "name": "idUE",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "valeur": {
-          "name": "valeur",
-          "type": "double precision",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "ajustements_numEtud_students_numEtud_fk": {
-          "name": "ajustements_numEtud_students_numEtud_fk",
-          "tableFrom": "ajustements",
-          "tableTo": "students",
-          "columnsFrom": [
-            "numEtud"
-          ],
-          "columnsTo": [
-            "numEtud"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        },
-        "ajustements_idUE_ues_id_fk": {
-          "name": "ajustements_idUE_ues_id_fk",
-          "tableFrom": "ajustements",
-          "tableTo": "ues",
-          "columnsFrom": [
-            "idUE"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {
-        "ajustements_numEtud_idUE_pk": {
-          "name": "ajustements_numEtud_idUE_pk",
-          "columns": [
-            "numEtud",
-            "idUE"
-          ]
-        }
-      },
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.enseignements": {
-      "name": "enseignements",
-      "schema": "",
-      "columns": {
-        "idProf": {
-          "name": "idProf",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "idModule": {
-          "name": "idModule",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "idPromo": {
-          "name": "idPromo",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "enseignements_idProf_users_id_fk": {
-          "name": "enseignements_idProf_users_id_fk",
-          "tableFrom": "enseignements",
-          "tableTo": "users",
-          "columnsFrom": [
-            "idProf"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        },
-        "enseignements_idModule_modules_id_fk": {
-          "name": "enseignements_idModule_modules_id_fk",
-          "tableFrom": "enseignements",
-          "tableTo": "modules",
-          "columnsFrom": [
-            "idModule"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        },
-        "enseignements_idPromo_promotions_idPromo_fk": {
-          "name": "enseignements_idPromo_promotions_idPromo_fk",
-          "tableFrom": "enseignements",
-          "tableTo": "promotions",
-          "columnsFrom": [
-            "idPromo"
-          ],
-          "columnsTo": [
-            "idPromo"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {
-        "enseignements_idProf_idModule_idPromo_pk": {
-          "name": "enseignements_idProf_idModule_idPromo_pk",
-          "columns": [
-            "idProf",
-            "idModule",
-            "idPromo"
-          ]
-        }
-      },
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.mobility": {
-      "name": "mobility",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": true
-        },
-        "studentId": {
-          "name": "studentId",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "startDate": {
-          "name": "startDate",
-          "type": "date",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "endDate": {
-          "name": "endDate",
-          "type": "date",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "weeksCount": {
-          "name": "weeksCount",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "destinationCountry": {
-          "name": "destinationCountry",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "destinationName": {
-          "name": "destinationName",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        },
-        "mobilityStatus": {
-          "name": "mobilityStatus",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false,
-          "default": "'N/A'"
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "mobility_studentId_students_numEtud_fk": {
-          "name": "mobility_studentId_students_numEtud_fk",
-          "tableFrom": "mobility",
-          "tableTo": "students",
-          "columnsFrom": [
-            "studentId"
-          ],
-          "columnsTo": [
-            "numEtud"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.modules": {
-      "name": "modules",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true
-        },
-        "nom": {
-          "name": "nom",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.notes": {
-      "name": "notes",
-      "schema": "",
-      "columns": {
-        "numEtud": {
-          "name": "numEtud",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "idModule": {
-          "name": "idModule",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "note": {
-          "name": "note",
-          "type": "double precision",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "notes_numEtud_students_numEtud_fk": {
-          "name": "notes_numEtud_students_numEtud_fk",
-          "tableFrom": "notes",
-          "tableTo": "students",
-          "columnsFrom": [
-            "numEtud"
-          ],
-          "columnsTo": [
-            "numEtud"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        },
-        "notes_idModule_modules_id_fk": {
-          "name": "notes_idModule_modules_id_fk",
-          "tableFrom": "notes",
-          "tableTo": "modules",
-          "columnsFrom": [
-            "idModule"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {
-        "notes_numEtud_idModule_pk": {
-          "name": "notes_numEtud_idModule_pk",
-          "columns": [
-            "numEtud",
-            "idModule"
-          ]
-        }
-      },
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.permissions": {
-      "name": "permissions",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true
-        },
-        "nom": {
-          "name": "nom",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.promotions": {
-      "name": "promotions",
-      "schema": "",
-      "columns": {
-        "idPromo": {
-          "name": "idPromo",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true
-        },
-        "annee": {
-          "name": "annee",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.role_permissions": {
-      "name": "role_permissions",
-      "schema": "",
-      "columns": {
-        "idRole": {
-          "name": "idRole",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "idPermission": {
-          "name": "idPermission",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "role_permissions_idRole_roles_id_fk": {
-          "name": "role_permissions_idRole_roles_id_fk",
-          "tableFrom": "role_permissions",
-          "tableTo": "roles",
-          "columnsFrom": [
-            "idRole"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        },
-        "role_permissions_idPermission_permissions_id_fk": {
-          "name": "role_permissions_idPermission_permissions_id_fk",
-          "tableFrom": "role_permissions",
-          "tableTo": "permissions",
-          "columnsFrom": [
-            "idPermission"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {
-        "role_permissions_idRole_idPermission_pk": {
-          "name": "role_permissions_idRole_idPermission_pk",
-          "columns": [
-            "idRole",
-            "idPermission"
-          ]
-        }
-      },
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.roles": {
-      "name": "roles",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": true
-        },
-        "nom": {
-          "name": "nom",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.students": {
-      "name": "students",
-      "schema": "",
-      "columns": {
-        "numEtud": {
-          "name": "numEtud",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": true
-        },
-        "nom": {
-          "name": "nom",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "prenom": {
-          "name": "prenom",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "idPromo": {
-          "name": "idPromo",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "students_idPromo_promotions_idPromo_fk": {
-          "name": "students_idPromo_promotions_idPromo_fk",
-          "tableFrom": "students",
-          "tableTo": "promotions",
-          "columnsFrom": [
-            "idPromo"
-          ],
-          "columnsTo": [
-            "idPromo"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.ue_modules": {
-      "name": "ue_modules",
-      "schema": "",
-      "columns": {
-        "idModule": {
-          "name": "idModule",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "idUE": {
-          "name": "idUE",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "idPromo": {
-          "name": "idPromo",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "coeff": {
-          "name": "coeff",
-          "type": "double precision",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "ue_modules_idModule_modules_id_fk": {
-          "name": "ue_modules_idModule_modules_id_fk",
-          "tableFrom": "ue_modules",
-          "tableTo": "modules",
-          "columnsFrom": [
-            "idModule"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        },
-        "ue_modules_idUE_ues_id_fk": {
-          "name": "ue_modules_idUE_ues_id_fk",
-          "tableFrom": "ue_modules",
-          "tableTo": "ues",
-          "columnsFrom": [
-            "idUE"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        },
-        "ue_modules_idPromo_promotions_idPromo_fk": {
-          "name": "ue_modules_idPromo_promotions_idPromo_fk",
-          "tableFrom": "ue_modules",
-          "tableTo": "promotions",
-          "columnsFrom": [
-            "idPromo"
-          ],
-          "columnsTo": [
-            "idPromo"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {
-        "ue_modules_idModule_idUE_idPromo_pk": {
-          "name": "ue_modules_idModule_idUE_idPromo_pk",
-          "columns": [
-            "idModule",
-            "idUE",
-            "idPromo"
-          ]
-        }
-      },
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.ues": {
-      "name": "ues",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "serial",
-          "primaryKey": true,
-          "notNull": true
-        },
-        "nom": {
-          "name": "nom",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {},
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    },
-    "public.users": {
-      "name": "users",
-      "schema": "",
-      "columns": {
-        "id": {
-          "name": "id",
-          "type": "text",
-          "primaryKey": true,
-          "notNull": true
-        },
-        "nom": {
-          "name": "nom",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "prenom": {
-          "name": "prenom",
-          "type": "text",
-          "primaryKey": false,
-          "notNull": true
-        },
-        "idRole": {
-          "name": "idRole",
-          "type": "integer",
-          "primaryKey": false,
-          "notNull": false
-        }
-      },
-      "indexes": {},
-      "foreignKeys": {
-        "users_idRole_roles_id_fk": {
-          "name": "users_idRole_roles_id_fk",
-          "tableFrom": "users",
-          "tableTo": "roles",
-          "columnsFrom": [
-            "idRole"
-          ],
-          "columnsTo": [
-            "id"
-          ],
-          "onDelete": "no action",
-          "onUpdate": "no action"
-        }
-      },
-      "compositePrimaryKeys": {},
-      "uniqueConstraints": {},
-      "policies": {},
-      "checkConstraints": {},
-      "isRLSEnabled": false
-    }
-  },
-  "enums": {},
-  "schemas": {},
-  "sequences": {},
-  "roles": {},
-  "policies": {},
-  "views": {},
-  "_meta": {
-    "columns": {},
-    "schemas": {},
-    "tables": {}
-  }
-}

databases/migrations/meta/_journal.json

@@ -1,13 +0,0 @@
-{
-  "version": "7",
-  "dialect": "postgresql",
-  "entries": [
-    {
-      "idx": 0,
-      "version": "7",
-      "when": 1777155028708,
-      "tag": "0000_square_jetstream",
-      "breakpoints": true
-    }
-  ]
-}

databases/schema.kit.ts

@@ -1,99 +0,0 @@
-import {
-  date,
-  doublePrecision,
-  integer,
-  pgTable,
-  primaryKey,
-  serial,
-  text,
-} from "drizzle-orm/pg-core";
-
-export const roles = pgTable("roles", {
-  id: serial("id").primaryKey(),
-  nom: text("nom").notNull(),
-});
-
-export const permissions = pgTable("permissions", {
-  id: text("id").primaryKey(),
-  nom: text("nom").notNull(),
-});
-
-export const rolePermissions = pgTable("role_permissions", {
-  idRole: integer("idRole").notNull().references(() => roles.id),
-  idPermission: text("idPermission").notNull().references(() => permissions.id),
-}, (t) => ({
-  pk: primaryKey({ columns: [t.idRole, t.idPermission] }),
-}));
-
-export const users = pgTable("users", {
-  id: text("id").primaryKey(),
-  nom: text("nom").notNull(),
-  prenom: text("prenom").notNull(),
-  idRole: integer("idRole").references(() => roles.id),
-});
-
-export const promotions = pgTable("promotions", {
-  id: text("idPromo").primaryKey(),
-  annee: text("annee"),
-});
-
-export const students = pgTable("students", {
-  numEtud: serial("numEtud").primaryKey(),
-  nom: text("nom").notNull(),
-  prenom: text("prenom").notNull(),
-  idPromo: text("idPromo").references(() => promotions.id),
-});
-
-export const modules = pgTable("modules", {
-  id: text("id").primaryKey(),
-  nom: text("nom").notNull(),
-});
-
-export const enseignements = pgTable("enseignements", {
-  idProf: text("idProf").notNull().references(() => users.id),
-  idModule: text("idModule").notNull().references(() => modules.id),
-  idPromo: text("idPromo").notNull().references(() => promotions.id),
-}, (t) => ({
-  pk: primaryKey({ columns: [t.idProf, t.idModule, t.idPromo] }),
-}));
-
-export const ues = pgTable("ues", {
-  id: serial("id").primaryKey(),
-  nom: text("nom").notNull(),
-});
-
-export const ueModules = pgTable("ue_modules", {
-  idModule: text("idModule").notNull().references(() => modules.id),
-  idUE: integer("idUE").notNull().references(() => ues.id),
-  idPromo: text("idPromo").notNull().references(() => promotions.id),
-  coeff: doublePrecision("coeff").notNull(),
-}, (t) => ({
-  pk: primaryKey({ columns: [t.idModule, t.idUE, t.idPromo] }),
-}));
-
-export const notes = pgTable("notes", {
-  numEtud: integer("numEtud").notNull().references(() => students.numEtud),
-  idModule: text("idModule").notNull().references(() => modules.id),
-  note: doublePrecision("note").notNull(),
-}, (t) => ({
-  pk: primaryKey({ columns: [t.numEtud, t.idModule] }),
-}));
-
-export const ajustements = pgTable("ajustements", {
-  numEtud: integer("numEtud").notNull().references(() => students.numEtud),
-  idUE: integer("idUE").notNull().references(() => ues.id),
-  valeur: doublePrecision("valeur").notNull(),
-}, (t) => ({
-  pk: primaryKey({ columns: [t.numEtud, t.idUE] }),
-}));
-
-export const mobility = pgTable("mobility", {
-  id: serial("id").primaryKey(),
-  studentId: integer("studentId").references(() => students.numEtud),
-  startDate: date("startDate"),
-  endDate: date("endDate"),
-  weeksCount: integer("weeksCount"),
-  destinationCountry: text("destinationCountry"),
-  destinationName: text("destinationName"),
-  mobilityStatus: text("mobilityStatus").default("N/A"),
-});

databases/schema.ts

@@ -1,12 +1,12 @@
 import {
   date,
-  doublePrecision,
   integer,
   pgTable,
   primaryKey,
+  real,
   serial,
   text,
-} from "npm:drizzle-orm@0.45.2/pg-core";
+} from "npm:drizzle-orm/pg-core";
 
 export const roles = pgTable("roles", {
   id: serial("id").primaryKey(),
@@ -33,15 +33,16 @@ export const users = pgTable("users", {
 });
 
 export const promotions = pgTable("promotions", {
-  id: text("idPromo").primaryKey(),
+  id: serial("id").primaryKey(),
-  annee: text("annee"),
+  endyear: integer("endyear"),
+  current: integer("current"),
 });
 
 export const students = pgTable("students", {
   numEtud: serial("numEtud").primaryKey(),
   nom: text("nom").notNull(),
   prenom: text("prenom").notNull(),
-  idPromo: text("idPromo").references(() => promotions.id),
+  idPromo: text("idPromo").references(() => promotions.id as unknown as string),
 });
 
 export const modules = pgTable("modules", {
@@ -52,7 +53,7 @@ export const modules = pgTable("modules", {
 export const enseignements = pgTable("enseignements", {
   idProf: text("idProf").notNull().references(() => users.id),
   idModule: text("idModule").notNull().references(() => modules.id),
-  idPromo: text("idPromo").notNull().references(() => promotions.id),
+  idPromo: text("idPromo").notNull(),
 }, (t) => ({
   pk: primaryKey({ columns: [t.idProf, t.idModule, t.idPromo] }),
 }));
@@ -65,8 +66,8 @@ export const ues = pgTable("ues", {
 export const ueModules = pgTable("ue_modules", {
   idModule: text("idModule").notNull().references(() => modules.id),
   idUE: integer("idUE").notNull().references(() => ues.id),
-  idPromo: text("idPromo").notNull().references(() => promotions.id),
+  idPromo: text("idPromo").notNull(),
-  coeff: doublePrecision("coeff").notNull(),
+  coeff: real("coeff").notNull(),
 }, (t) => ({
   pk: primaryKey({ columns: [t.idModule, t.idUE, t.idPromo] }),
 }));
@@ -74,7 +75,7 @@ export const ueModules = pgTable("ue_modules", {
 export const notes = pgTable("notes", {
   numEtud: integer("numEtud").notNull().references(() => students.numEtud),
   idModule: text("idModule").notNull().references(() => modules.id),
-  note: doublePrecision("note").notNull(),
+  note: real("note").notNull(),
 }, (t) => ({
   pk: primaryKey({ columns: [t.numEtud, t.idModule] }),
 }));
@@ -82,7 +83,7 @@ export const notes = pgTable("notes", {
 export const ajustements = pgTable("ajustements", {
   numEtud: integer("numEtud").notNull().references(() => students.numEtud),
   idUE: integer("idUE").notNull().references(() => ues.id),
-  valeur: doublePrecision("valeur").notNull(),
+  valeur: real("valeur").notNull(),
 }, (t) => ({
   pk: primaryKey({ columns: [t.numEtud, t.idUE] }),
 }));

deno.json

@@ -10,10 +10,7 @@
     "build": "deno run -A --unstable-ffi dev.ts build",
     "preview": "deno run -A --unstable-ffi main.ts",
     "update": "deno run -A -r https://fresh.deno.dev/update .",
-    "test": "deno test -A --no-check tests/",
+    "test": "deno test -A --no-check tests/"
-    "test:unit": "deno test -A --no-check tests/unit/",
-    "test:integration": "deno test -A --no-check tests/integration/",
-    "migrate": "node_modules/.bin/drizzle-kit migrate"
   },
   "lint": {
     "rules": {

drizzle.config.ts

@@ -1,17 +1,14 @@
 import { defineConfig } from "drizzle-kit";
-import process from "node:process";
-
-const url = process.env.DATABASE_URL ??
-  `postgresql://${process.env.POSTGRES_USER}:${process.env.POSTGRES_PASS}@${
-    process.env.POSTGRES_HOST ?? "localhost"
-  }:${process.env.POSTGRES_PORT ?? 5432}/${process.env.POSTGRES_DB}`;
 
 export default defineConfig({
   dialect: "postgresql",
-  schema: "./databases/schema.kit.ts",
+  schema: "./databases/schema.ts",
   out: "./databases/migrations",
   dbCredentials: {
-    url,
+    host: process.env.POSTGRES_HOST!,
-    ssl: false,
+    port: Number(process.env.POSTGRES_PORT ?? 5432),
+    user: process.env.POSTGRES_USER!,
+    password: process.env.POSTGRES_PASS!,
+    database: process.env.POSTGRES_DB!,
   },
 });

flake.lock

@@ -1,61 +0,0 @@
-{
-  "nodes": {
-    "flake-utils": {
-      "inputs": {
-        "systems": "systems"
-      },
-      "locked": {
-        "lastModified": 1731533236,
-        "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=",
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b",
-        "type": "github"
-      },
-      "original": {
-        "owner": "numtide",
-        "repo": "flake-utils",
-        "type": "github"
-      }
-    },
-    "nixpkgs": {
-      "locked": {
-        "lastModified": 1776548001,
-        "narHash": "sha256-ZSK0NL4a1BwVbbTBoSnWgbJy9HeZFXLYQizjb2DPF24=",
-        "owner": "NixOS",
-        "repo": "nixpkgs",
-        "rev": "b12141ef619e0a9c1c84dc8c684040326f27cdcc",
-        "type": "github"
-      },
-      "original": {
-        "owner": "NixOS",
-        "ref": "nixos-unstable",
-        "repo": "nixpkgs",
-        "type": "github"
-      }
-    },
-    "root": {
-      "inputs": {
-        "flake-utils": "flake-utils",
-        "nixpkgs": "nixpkgs"
-      }
-    },
-    "systems": {
-      "locked": {
-        "lastModified": 1681028828,
-        "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=",
-        "owner": "nix-systems",
-        "repo": "default",
-        "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e",
-        "type": "github"
-      },
-      "original": {
-        "owner": "nix-systems",
-        "repo": "default",
-        "type": "github"
-      }
-    }
-  },
-  "root": "root",
-  "version": 7
-}

flake.nix

@@ -1,62 +0,0 @@
-{
-  description = "PolyMPR CLI - A tool for managing PolyMPR modules";
-
-  inputs = {
-    nixpkgs.url = "github:NixOS/nixpkgs/nixos-unstable";
-    flake-utils.url = "github:numtide/flake-utils";
-  };
-
-  outputs = { self, nixpkgs, flake-utils }:
-    flake-utils.lib.eachDefaultSystem (system:
-      let
-        pkgs = nixpkgs.legacyPackages.${system};
-      in
-      {
-        packages.pmpr = pkgs.stdenv.mkDerivation {
-          pname = "pmpr";
-          version = "0.1.0";
-          src = ./.;
-
-          nativeBuildInputs = [
-            pkgs.deno
-            pkgs.autoPatchelfHook
-          ];
-
-          buildInputs = [
-            pkgs.stdenv.cc.cc.lib
-          ];
-
-          buildPhase = ''
-            export HOME=$TMPDIR
-            deno cache toolbox/cli.ts
-            deno compile -A --output pmpr toolbox/cli.ts
-          '';
-
-          installPhase = ''
-            mkdir -p $out/bin
-            cp pmpr $out/bin/pmpr
-          '';
-        };
-
-        packages.default = self.packages.${system}.pmpr;
-
-        devShells.default = pkgs.mkShell {
-          nativeBuildInputs = [
-            pkgs.deno
-            pkgs.patchelf
-          ];
-
-          buildInputs = [
-            pkgs.stdenv.cc.cc.lib
-          ];
-
-          shellHook = ''
-            export LD_LIBRARY_PATH="${pkgs.stdenv.cc.cc.lib}/lib:$LD_LIBRARY_PATH"
-            export NIX_LD_INTERPRETER=$(cat ${pkgs.stdenv.cc}/nix-support/dynamic-linker)
-            echo "Welcome to PolyMPR development shell!"
-            echo "Use 'deno task compile' to build the CLI."
-          '';
-        };
-      }
-    );
-}

routes/(apps)/admin/(_props)/props.ts

@@ -1,13 +0,0 @@
-import { AppProperties } from "$root/defaults/interfaces.ts";
-
-const properties: AppProperties = {
-  name: "Admin",
-  icon: "school",
-  pages: {
-    index: "Homepage",
-  },
-  adminOnly: [],
-  hint: "PolyMPR module",
-};
-
-export default properties;

routes/(apps)/admin/api/enseignements.ts

@@ -1,70 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { enseignements } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { and, eq } from "npm:drizzle-orm@0.45.2";
-
-const _NOT_FOUND = new Response(
-  JSON.stringify({ error: "Ressource introuvable" }),
-  { status: 404, headers: { "content-type": "application/json" } },
-);
-
-const FORBIDDEN = new Response(null, { status: 403 });
-
-const CONFLICT = new Response(
-  JSON.stringify({ error: "Cet enseignement existe déjà." }),
-  { status: 409, headers: { "content-type": "application/json" } },
-);
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #29 POST /enseignements
-  async POST(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const body: {
-      idProf: string;
-      idModule: string;
-      idPromo: string;
-    } = await request.json();
-
-    if (!body.idProf || !body.idModule || !body.idPromo) {
-      return new Response(null, { status: 400 });
-    }
-
-    // Check if enseignement already exists
-    const existing = await db
-      .select()
-      .from(enseignements)
-      .where(
-        and(
-          eq(enseignements.idProf, body.idProf),
-          eq(enseignements.idModule, body.idModule),
-          eq(enseignements.idPromo, body.idPromo),
-        ),
-      )
-      .then((rows) => rows[0] ?? null);
-
-    if (existing) {
-      return CONFLICT;
-    }
-
-    const [created] = await db
-      .insert(enseignements)
-      .values({
-        idProf: body.idProf,
-        idModule: body.idModule,
-        idPromo: body.idPromo,
-      })
-      .returning();
-
-    return new Response(JSON.stringify(created), {
-      status: 201,
-      headers: { "content-type": "application/json" },
-    });
-  },
-};

routes/(apps)/admin/api/enseignements/[idProf]/[idModule]/[idPromo].ts

@@ -1,75 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { enseignements } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { and, eq } from "npm:drizzle-orm@0.45.2";
-
-const NOT_FOUND = new Response(
-  JSON.stringify({ error: "Ressource introuvable" }),
-  { status: 404, headers: { "content-type": "application/json" } },
-);
-
-const FORBIDDEN = new Response(null, { status: 403 });
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #30 GET /enseignements/{idProf}/{idModule}/{idPromo}
-  async GET(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const idProf = context.params.idProf;
-    const idModule = context.params.idModule;
-    const idPromo = context.params.idPromo;
-
-    const enseignement = await db
-      .select()
-      .from(enseignements)
-      .where(
-        and(
-          eq(enseignements.idProf, idProf),
-          eq(enseignements.idModule, idModule),
-          eq(enseignements.idPromo, idPromo),
-        ),
-      )
-      .then((rows) => rows[0] ?? null);
-
-    if (!enseignement) return NOT_FOUND;
-
-    return new Response(JSON.stringify(enseignement), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #31 DELETE /enseignements/{idProf}/{idModule}/{idPromo}
-  async DELETE(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const idProf = context.params.idProf;
-    const idModule = context.params.idModule;
-    const idPromo = context.params.idPromo;
-
-    const [deleted] = await db
-      .delete(enseignements)
-      .where(
-        and(
-          eq(enseignements.idProf, idProf),
-          eq(enseignements.idModule, idModule),
-          eq(enseignements.idPromo, idPromo),
-        ),
-      )
-      .returning();
-
-    if (!deleted) return NOT_FOUND;
-
-    return new Response(null, { status: 204 });
-  },
-};

routes/(apps)/admin/api/example.ts

@@ -1,22 +0,0 @@
-import { Handlers } from "$fresh/server.ts";
-
-export const handler: Handlers = {
-  async POST(request, context) {
-    if (request.headers.get("content-type") != "application/json") {
-      return new Response(null, {
-        status: 400,
-      });
-    }
-
-    const responseBody = {
-      requestBody: await request.json(),
-      context,
-    };
-
-    return new Response(JSON.stringify(responseBody), {
-      headers: {
-        "content-type": "application/json",
-      },
-    });
-  },
-};

routes/(apps)/admin/api/modules.ts

@@ -1,63 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { modules } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #23 GET /modules
-  async GET(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return new Response(JSON.stringify([]), {
-        headers: { "content-type": "application/json" },
-      });
-    }
-
-    const rows = await db.select().from(modules);
-    return new Response(JSON.stringify(rows), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #24 POST /modules
-  async POST(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return new Response(null, { status: 403 });
-    }
-
-    const body: { id: string; nom: string } = await request.json();
-
-    if (!body.id || !body.nom) {
-      return new Response(null, { status: 400 });
-    }
-
-    const existing = await db
-      .select()
-      .from(modules)
-      .where(eq(modules.id, body.id))
-      .then((rows) => rows[0] ?? null);
-
-    if (existing) {
-      return new Response(
-        JSON.stringify({ error: "Un module avec cet identifiant existe déjà" }),
-        { status: 409, headers: { "content-type": "application/json" } },
-      );
-    }
-
-    const [created] = await db
-      .insert(modules)
-      .values({ id: body.id, nom: body.nom })
-      .returning();
-
-    return new Response(JSON.stringify(created), {
-      status: 201,
-      headers: { "content-type": "application/json" },
-    });
-  },
-};

routes/(apps)/admin/api/modules/[idModule].ts

@@ -1,65 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { modules } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-const NOT_FOUND = new Response(
-  JSON.stringify({ error: "Ressource introuvable" }),
-  { status: 404, headers: { "content-type": "application/json" } },
-);
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #25 GET /modules/{idModule}
-  async GET(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const module = await db
-      .select()
-      .from(modules)
-      .where(eq(modules.id, context.params.idModule))
-      .then((rows) => rows[0] ?? null);
-
-    if (!module) return NOT_FOUND;
-
-    return new Response(JSON.stringify(module), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #26 PUT /modules/{idModule}
-  async PUT(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const body: { nom: string } = await request.json();
-
-    const [updated] = await db
-      .update(modules)
-      .set({ nom: body.nom })
-      .where(eq(modules.id, context.params.idModule))
-      .returning();
-
-    if (!updated) return NOT_FOUND;
-
-    return new Response(JSON.stringify(updated), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #27 DELETE /modules/{idModule}
-  async DELETE(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const [deleted] = await db
-      .delete(modules)
-      .where(eq(modules.id, context.params.idModule))
-      .returning();
-
-    if (!deleted) return NOT_FOUND;
-
-    return new Response(null, { status: 204 });
-  },
-};

routes/(apps)/admin/api/permissions.ts

@@ -1,22 +0,0 @@
-import { Handlers } from "$fresh/server.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-
-const PERMISSIONS = [
-  { id: "student_read", nom: "Consulter les élèves" },
-  { id: "student_write", nom: "Gérer les élèves" },
-  { id: "note_read", nom: "Consulter les notes" },
-  { id: "note_write", nom: "Gérer les notes" },
-  { id: "module_read", nom: "Consulter les modules" },
-  { id: "module_write", nom: "Gérer les modules" },
-  { id: "user_read", nom: "Consulter les utilisateurs" },
-  { id: "user_write", nom: "Gérer les utilisateurs" },
-  { id: "role_write", nom: "Gérer les rôles" },
-] as const;
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  GET(_request, _context): Response {
-    return new Response(JSON.stringify(PERMISSIONS), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-};

routes/(apps)/admin/api/roles.ts

@@ -1,68 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { rolePermissions, roles } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-async function getRoleWithPermissions(
-  id: number,
-): Promise<{ id: number; nom: string; permissions: string[] } | null> {
-  const role = await db
-    .select()
-    .from(roles)
-    .where(eq(roles.id, id))
-    .then((rows) => rows[0] ?? null);
-
-  if (!role) return null;
-
-  const perms = await db
-    .select({ idPermission: rolePermissions.idPermission })
-    .from(rolePermissions)
-    .where(eq(rolePermissions.idRole, id));
-
-  return {
-    id: role.id,
-    nom: role.nom,
-    permissions: perms.map((p) => p.idPermission),
-  };
-}
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #65 GET /roles
-  async GET(
-    _request: Request,
-    _context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const allRoles = await db.select().from(roles);
-
-    const result = await Promise.all(
-      allRoles.map((r) => getRoleWithPermissions(r.id)),
-    );
-
-    return new Response(JSON.stringify(result), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #66 POST /roles
-  async POST(
-    request: Request,
-    _context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const body: { nom: string } = await request.json();
-
-    if (!body.nom) {
-      return new Response(null, { status: 400 });
-    }
-
-    const [created] = await db
-      .insert(roles)
-      .values({ nom: body.nom })
-      .returning();
-
-    return new Response(
-      JSON.stringify({ id: created.id, nom: created.nom, permissions: [] }),
-      { status: 201, headers: { "content-type": "application/json" } },
-    );
-  },
-};

routes/(apps)/admin/api/roles/[idRole].ts

@@ -1,101 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { rolePermissions, roles } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-const NOT_FOUND = new Response(
-  JSON.stringify({ error: "Ressource introuvable" }),
-  { status: 404, headers: { "content-type": "application/json" } },
-);
-
-async function getRoleWithPermissions(
-  id: number,
-): Promise<{ id: number; nom: string; permissions: string[] } | null> {
-  const role = await db
-    .select()
-    .from(roles)
-    .where(eq(roles.id, id))
-    .then((rows) => rows[0] ?? null);
-
-  if (!role) return null;
-
-  const perms = await db
-    .select({ idPermission: rolePermissions.idPermission })
-    .from(rolePermissions)
-    .where(eq(rolePermissions.idRole, id));
-
-  return {
-    id: role.id,
-    nom: role.nom,
-    permissions: perms.map((p) => p.idPermission),
-  };
-}
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #67 GET /roles/{idRole}
-  async GET(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const id = Number(context.params.idRole);
-    const role = await getRoleWithPermissions(id);
-
-    if (!role) return NOT_FOUND;
-
-    return new Response(JSON.stringify(role), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #68 PUT /roles/{idRole}
-  async PUT(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const id = Number(context.params.idRole);
-    const body: { nom: string; permissions: string[] } = await request.json();
-
-    const [updated] = await db
-      .update(roles)
-      .set({ nom: body.nom })
-      .where(eq(roles.id, id))
-      .returning();
-
-    if (!updated) return NOT_FOUND;
-
-    // Reset permissions
-    await db.delete(rolePermissions).where(eq(rolePermissions.idRole, id));
-
-    if (body.permissions?.length) {
-      await db.insert(rolePermissions).values(
-        body.permissions.map((p) => ({ idRole: id, idPermission: p })),
-      );
-    }
-
-    const role = await getRoleWithPermissions(id);
-    return new Response(JSON.stringify(role), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #69 DELETE /roles/{idRole}
-  async DELETE(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const id = Number(context.params.idRole);
-
-    // Cascade delete role_permissions first
-    await db.delete(rolePermissions).where(eq(rolePermissions.idRole, id));
-
-    const [deleted] = await db
-      .delete(roles)
-      .where(eq(roles.id, id))
-      .returning();
-
-    if (!deleted) return NOT_FOUND;
-
-    return new Response(null, { status: 204 });
-  },
-};

routes/(apps)/admin/api/users.ts

@@ -1,67 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { users } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #60 GET /users
-  async GET(
-    request: Request,
-    _context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const url = new URL(request.url);
-    const idRole = url.searchParams.get("idRole");
-
-    const rows = idRole
-      ? await db.select().from(users).where(eq(users.idRole, Number(idRole)))
-      : await db.select().from(users);
-
-    return new Response(JSON.stringify(rows), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #61 POST /users
-  async POST(
-    request: Request,
-    _context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const body: { id: string; nom: string; prenom: string; idRole: number } =
-      await request.json();
-
-    if (!body.id || !body.nom || !body.prenom) {
-      return new Response(null, { status: 400 });
-    }
-
-    const existing = await db
-      .select()
-      .from(users)
-      .where(eq(users.id, body.id))
-      .then((rows) => rows[0] ?? null);
-
-    if (existing) {
-      return new Response(
-        JSON.stringify({
-          error: "Un utilisateur avec cet identifiant existe déjà",
-        }),
-        { status: 409, headers: { "content-type": "application/json" } },
-      );
-    }
-
-    const [created] = await db
-      .insert(users)
-      .values({
-        id: body.id,
-        nom: body.nom,
-        prenom: body.prenom,
-        idRole: body.idRole,
-      })
-      .returning();
-
-    return new Response(JSON.stringify(created), {
-      status: 201,
-      headers: { "content-type": "application/json" },
-    });
-  },
-};

routes/(apps)/admin/api/users/[id].ts

@@ -1,66 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { users } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-const NOT_FOUND = new Response(
-  JSON.stringify({ error: "Ressource introuvable" }),
-  { status: 404, headers: { "content-type": "application/json" } },
-);
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #62 GET /users/{id}
-  async GET(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const user = await db
-      .select()
-      .from(users)
-      .where(eq(users.id, context.params.id))
-      .then((rows) => rows[0] ?? null);
-
-    if (!user) return NOT_FOUND;
-
-    return new Response(JSON.stringify(user), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #63 PUT /users/{id}
-  async PUT(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const body: { nom: string; prenom: string; idRole: number } = await request
-      .json();
-
-    const [updated] = await db
-      .update(users)
-      .set({ nom: body.nom, prenom: body.prenom, idRole: body.idRole })
-      .where(eq(users.id, context.params.id))
-      .returning();
-
-    if (!updated) return NOT_FOUND;
-
-    return new Response(JSON.stringify(updated), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #64 DELETE /users/{id}
-  async DELETE(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    const [deleted] = await db
-      .delete(users)
-      .where(eq(users.id, context.params.id))
-      .returning();
-
-    if (!deleted) return NOT_FOUND;
-
-    return new Response(null, { status: 204 });
-  },
-};

routes/(apps)/admin/index.tsx

@@ -1,2 +0,0 @@
-import makeIndex from "$root/defaults/makeIndex.ts";
-export default makeIndex(import.meta.dirname!);

routes/(apps)/admin/partials/index.tsx

@@ -1,13 +0,0 @@
-import {
-  getPartialsConfig,
-  makePartials,
-} from "$root/defaults/makePartials.tsx";
-import { FreshContext } from "$fresh/server.ts";
-import { State } from "$root/routes/_middleware.ts";
-
-export function Index(_request: Request, _context: FreshContext<State>) {
-  return <h2>Welcome to Admin.</h2>;
-}
-
-export const config = getPartialsConfig();
-export default makePartials(Index);

routes/(apps)/mobility/api/insert_mobility.ts

@@ -1,7 +1,7 @@
 import { Handlers } from "$fresh/server.ts";
 import { db } from "$root/databases/db.ts";
 import { mobility, promotions, students } from "$root/databases/schema.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
+import { eq } from "npm:drizzle-orm";
 
 export const handler: Handlers = {
   async GET() {
@@ -21,11 +21,7 @@ export const handler: Handlers = {
       const mobilityRows = await db.select().from(mobility);
 
       const promotionRows = await db
-        .select({
+        .select({ id: promotions.id, endyear: promotions.endyear, current: promotions.current })
-          id: promotions.id,
-          endyear: promotions.endyear,
-          current: promotions.current,
-        })
         .from(promotions);
 
       return new Response(
@@ -111,9 +107,7 @@ export const handler: Handlers = {
           });
       }
 
-      return new Response("Data inserted/updated successfully", {
+      return new Response("Data inserted/updated successfully", { status: 200 });
-        status: 200,
-      });
     } catch (error) {
       console.error("Error inserting mobility data:", error);
       return new Response("Failed to insert/update data", { status: 500 });

routes/(apps)/notes/api/ajustements.ts

@@ -1,83 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { ajustements } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #48 GET /ajustements
-  async GET(request) {
-    try {
-      const url = new URL(request.url);
-      const numEtudParam = url.searchParams.get("numEtud");
-      const idUEParam = url.searchParams.get("idUE");
-
-      let query = db.select().from(ajustements).$dynamic();
-
-      if (numEtudParam) {
-        const numEtud = parseInt(numEtudParam);
-        if (isNaN(numEtud)) {
-          return new Response("Paramètre numEtud invalide", { status: 400 });
-        }
-        query = query.where(eq(ajustements.numEtud, numEtud));
-      }
-
-      if (idUEParam) {
-        const idUE = parseInt(idUEParam);
-        if (isNaN(idUE)) {
-          return new Response("Paramètre idUE invalide", { status: 400 });
-        }
-        query = query.where(eq(ajustements.idUE, idUE));
-      }
-
-      const result = await query;
-
-      return new Response(JSON.stringify(result), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error fetching ajustements:", error);
-      return new Response("Failed to fetch data", { status: 500 });
-    }
-  },
-
-  // #49 POST /ajustements
-  async POST(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return new Response(null, { status: 403 });
-    }
-
-    try {
-      const body: { numEtud: number; idUE: number; valeur: number } =
-        await request.json();
-
-      if (!body.numEtud || !body.idUE || body.valeur === undefined) {
-        return new Response(
-          JSON.stringify({ error: "Champs requis: numEtud, idUE, valeur" }),
-          { status: 400, headers: { "content-type": "application/json" } },
-        );
-      }
-
-      const [created] = await db
-        .insert(ajustements)
-        .values({
-          numEtud: body.numEtud,
-          idUE: body.idUE,
-          valeur: body.valeur,
-        })
-        .returning();
-
-      return new Response(JSON.stringify(created), {
-        status: 201,
-        headers: { "content-type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error creating ajustement:", error);
-      return new Response("Failed to create ajustement", { status: 500 });
-    }
-  },
-};

routes/(apps)/notes/api/ajustements/[numEtud]/[idUE].ts

@@ -1,107 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { ajustements } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-const NOT_FOUND = new Response(
-  JSON.stringify({ error: "Ajustement introuvable" }),
-  { status: 404, headers: { "content-type": "application/json" } },
-);
-
-const FORBIDDEN = new Response(null, { status: 403 });
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #50 GET /ajustements/{numEtud}/{idUE}
-  async GET(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const numEtud = Number(context.params.numEtud);
-    const idUE = Number(context.params.idUE);
-
-    if (isNaN(numEtud) || isNaN(idUE)) {
-      return new Response("Paramètres invalides", { status: 400 });
-    }
-
-    const ajustement = await db
-      .select()
-      .from(ajustements)
-      .where(eq(ajustements.numEtud, numEtud), eq(ajustements.idUE, idUE))
-      .then((rows) => rows[0] ?? null);
-
-    if (!ajustement) return NOT_FOUND;
-
-    return new Response(JSON.stringify(ajustement), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #51 PUT /ajustements/{numEtud}/{idUE}
-  async PUT(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const numEtud = Number(context.params.numEtud);
-    const idUE = Number(context.params.idUE);
-
-    if (isNaN(numEtud) || isNaN(idUE)) {
-      return new Response("Paramètres invalides", { status: 400 });
-    }
-
-    const body: { valeur: number } = await request.json();
-
-    if (body.valeur === undefined) {
-      return new Response(JSON.stringify({ error: "Champ requis: valeur" }), {
-        status: 400,
-        headers: { "content-type": "application/json" },
-      });
-    }
-
-    const [updated] = await db
-      .update(ajustements)
-      .set({ valeur: body.valeur })
-      .where(eq(ajustements.numEtud, numEtud), eq(ajustements.idUE, idUE))
-      .returning();
-
-    if (!updated) return NOT_FOUND;
-
-    return new Response(JSON.stringify(updated), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #52 DELETE /ajustements/{numEtud}/{idUE}
-  async DELETE(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const numEtud = Number(context.params.numEtud);
-    const idUE = Number(context.params.idUE);
-
-    if (isNaN(numEtud) || isNaN(idUE)) {
-      return new Response("Paramètres invalides", { status: 400 });
-    }
-
-    const [deleted] = await db
-      .delete(ajustements)
-      .where(eq(ajustements.numEtud, numEtud), eq(ajustements.idUE, idUE))
-      .returning();
-
-    if (!deleted) return NOT_FOUND;
-
-    return new Response(null, { status: 204 });
-  },
-};

routes/(apps)/notes/api/notes.ts

@@ -1,64 +0,0 @@
-import { Handlers } from "$fresh/server.ts";
-import { db } from "../../../../databases/db.ts";
-import { notes } from "../../../../databases/schema.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-export const handler: Handlers = {
-  // #42 GET /notes
-  async GET(request) {
-    try {
-      const url = new URL(request.url);
-      const numEtudParam = url.searchParams.get("numEtud");
-      const idModule = url.searchParams.get("idModule");
-
-      let query = db.select().from(notes).$dynamic();
-
-      if (numEtudParam) {
-        const numEtud = parseInt(numEtudParam);
-        if (isNaN(numEtud)) {
-          return new Response("Paramètre numEtud invalide", { status: 400 });
-        }
-        query = query.where(eq(notes.numEtud, numEtud));
-      }
-
-      if (idModule) {
-        query = query.where(eq(notes.idModule, idModule));
-      }
-
-      const result = await query;
-
-      return new Response(JSON.stringify(result), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error fetching notes:", error);
-      return new Response("Failed to fetch data", { status: 500 });
-    }
-  },
-
-  // #43 POST /notes
-  async POST(request) {
-    try {
-      const body = await request.json();
-      const { note, numEtud, idModule } = body;
-
-      if (note === undefined || !numEtud || !idModule) {
-        return new Response("Champs 'note', 'numEtud' et 'idModule' requis", {
-          status: 400,
-        });
-      }
-
-      const result = await db.insert(notes).values({ note, numEtud, idModule })
-        .returning();
-
-      return new Response(JSON.stringify(result[0]), {
-        status: 201,
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error creating note:", error);
-      return new Response("Failed to create note", { status: 500 });
-    }
-  },
-};

routes/(apps)/notes/api/notes/[numEtud]/[idModule].ts

@@ -1,139 +0,0 @@
-import { Handlers } from "$fresh/server.ts";
-import { db } from "../../../../../../databases/db.ts";
-import { notes } from "../../../../../../databases/schema.ts";
-import { and, eq } from "npm:drizzle-orm@0.45.2";
-
-export const handler: Handlers = {
-  // #45 GET /notes/:numEtud/:idModule
-  async GET(_request, context) {
-    try {
-      const numEtud = parseInt(context.params.numEtud);
-      const { idModule } = context.params;
-
-      if (isNaN(numEtud)) {
-        return new Response(
-          JSON.stringify({ error: "Paramètre numEtud invalide" }),
-          {
-            status: 400,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      const result = await db.select().from(notes).where(
-        and(
-          eq(notes.numEtud, numEtud),
-          eq(notes.idModule, idModule),
-        ),
-      );
-
-      if (result.length === 0) {
-        return new Response(
-          JSON.stringify({ error: "Ressource introuvable" }),
-          {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      return new Response(JSON.stringify(result[0]), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error fetching note:", error);
-      return new Response("Failed to fetch data", { status: 500 });
-    }
-  },
-
-  // #46 PUT /notes/:numEtud/:idModule
-  async PUT(request, context) {
-    try {
-      const numEtud = parseInt(context.params.numEtud);
-      const { idModule } = context.params;
-
-      if (isNaN(numEtud)) {
-        return new Response(
-          JSON.stringify({ error: "Paramètre numEtud invalide" }),
-          {
-            status: 400,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      const body = await request.json();
-      const { note } = body;
-
-      if (note === undefined) {
-        return new Response("Champ 'note' manquant", { status: 400 });
-      }
-
-      const result = await db.update(notes).set({ note }).where(
-        and(
-          eq(notes.numEtud, numEtud),
-          eq(notes.idModule, idModule),
-        ),
-      ).returning();
-
-      if (result.length === 0) {
-        return new Response(
-          JSON.stringify({ error: "Ressource introuvable" }),
-          {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      return new Response(JSON.stringify(result[0]), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error updating note:", error);
-      return new Response("Failed to update note", { status: 500 });
-    }
-  },
-
-  // #47 DELETE /notes/:numEtud/:idModule
-  async DELETE(_request, context) {
-    try {
-      const numEtud = parseInt(context.params.numEtud);
-      const { idModule } = context.params;
-
-      if (isNaN(numEtud)) {
-        return new Response(
-          JSON.stringify({ error: "Paramètre numEtud invalide" }),
-          {
-            status: 400,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      const result = await db.delete(notes).where(
-        and(
-          eq(notes.numEtud, numEtud),
-          eq(notes.idModule, idModule),
-        ),
-      ).returning();
-
-      if (result.length === 0) {
-        return new Response(
-          JSON.stringify({ error: "Ressource introuvable" }),
-          {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      return new Response(null, { status: 204 });
-    } catch (error) {
-      console.error("Error deleting note:", error);
-      return new Response("Failed to delete note", { status: 500 });
-    }
-  },
-};

routes/(apps)/notes/api/ue-modules.ts

@@ -1,66 +0,0 @@
-import { Handlers } from "$fresh/server.ts";
-import { db } from "../../../../databases/db.ts";
-import { ueModules } from "../../../../databases/schema.ts";
-import { and, eq } from "npm:drizzle-orm@0.45.2";
-
-export const handler: Handlers = {
-  // #37 GET /ue-modules
-  async GET(request) {
-    try {
-      const url = new URL(request.url);
-      const idPromo = url.searchParams.get("idPromo");
-      const idUEParam = url.searchParams.get("idUE");
-
-      const idUE = idUEParam ? parseInt(idUEParam) : null;
-
-      if (idUEParam && isNaN(idUE!)) {
-        return new Response("Paramètre idUE invalide", { status: 400 });
-      }
-
-      const result = await db.select().from(ueModules).where(
-        and(
-          idPromo ? eq(ueModules.idPromo, idPromo) : undefined,
-          idUE ? eq(ueModules.idUE, idUE) : undefined,
-        ),
-      );
-
-      return new Response(JSON.stringify(result), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error fetching UE-modules:", error);
-      return new Response("Failed to fetch data", { status: 500 });
-    }
-  },
-
-  // #38 POST /ue-modules
-  async POST(request) {
-    try {
-      const body = await request.json();
-      const { idModule, idUE, idPromo, coeff } = body;
-
-      if (!idModule || !idUE || !idPromo || coeff === undefined) {
-        return new Response(
-          "Champs 'idModule', 'idUE', 'idPromo' et 'coeff' requis",
-          { status: 400 },
-        );
-      }
-
-      const result = await db.insert(ueModules).values({
-        idModule,
-        idUE,
-        idPromo,
-        coeff,
-      }).returning();
-
-      return new Response(JSON.stringify(result[0]), {
-        status: 201,
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error creating UE-module:", error);
-      return new Response("Failed to create UE-module", { status: 500 });
-    }
-  },
-};

routes/(apps)/notes/api/ue-modules/[idModule]/[idUE]/[idPromo].ts

@@ -1,139 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { ueModules } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { and, eq } from "npm:drizzle-orm@0.45.2";
-
-const NOT_FOUND = new Response(
-  JSON.stringify({ error: "Association UE-Module introuvable" }),
-  { status: 404, headers: { "content-type": "application/json" } },
-);
-
-const FORBIDDEN = new Response(null, { status: 403 });
-
-const BAD_REQUEST = new Response(
-  JSON.stringify({ error: "Paramètres invalides" }),
-  { status: 400, headers: { "content-type": "application/json" } },
-);
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #39 GET /ue-modules/{idModule}/{idUE}/{idPromo}
-  async GET(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const idModule = context.params.idModule;
-    const idUE = Number(context.params.idUE);
-    const idPromo = context.params.idPromo;
-
-    if (isNaN(idUE)) {
-      return BAD_REQUEST;
-    }
-
-    const ueModuleAssociation = await db
-      .select()
-      .from(ueModules)
-      .where(
-        eq(ueModules.idModule, idModule),
-        eq(ueModules.idUE, idUE),
-        eq(ueModules.idPromo, idPromo),
-      )
-      .then((rows) => rows[0] ?? null);
-
-    if (!ueModuleAssociation) return NOT_FOUND;
-
-    return new Response(JSON.stringify(ueModuleAssociation), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #40 PUT /ue-modules/{idModule}/{idUE}/{idPromo}
-  async PUT(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const idModule = context.params.idModule;
-    const idUE = Number(context.params.idUE);
-    const idPromo = context.params.idPromo;
-
-    if (isNaN(idUE)) {
-      return BAD_REQUEST;
-    }
-
-    const body: { coeff: number } = await request.json();
-
-    if (typeof body.coeff !== "number") {
-      return new Response(
-        JSON.stringify({ error: "Le champ 'coeff' doit être un nombre" }),
-        { status: 400, headers: { "content-type": "application/json" } },
-      );
-    }
-
-    const [updated] = await db
-      .update(ueModules)
-      .set({ coeff: body.coeff })
-      .where(
-        and(
-          eq(ueModules.idModule, idModule),
-          eq(ueModules.idUE, idUE),
-          eq(ueModules.idPromo, idPromo),
-        ),
-      )
-      .returning();
-
-    if (!updated) return NOT_FOUND;
-
-    return new Response(
-      JSON.stringify({
-        idModule: updated.idModule,
-        idUE: updated.idUE,
-        idPromo: updated.idPromo,
-        coeff: updated.coeff,
-      }),
-      {
-        headers: { "content-type": "application/json" },
-      },
-    );
-  },
-
-  // #41 DELETE /ue-modules/{idModule}/{idUE}/{idPromo}
-  async DELETE(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const idModule = context.params.idModule;
-    const idUE = Number(context.params.idUE);
-    const idPromo = context.params.idPromo;
-
-    if (isNaN(idUE)) {
-      return BAD_REQUEST;
-    }
-
-    const [deleted] = await db
-      .delete(ueModules)
-      .where(
-        and(
-          eq(ueModules.idModule, idModule),
-          eq(ueModules.idUE, idUE),
-          eq(ueModules.idPromo, idPromo),
-        ),
-      )
-      .returning();
-
-    if (!deleted) return NOT_FOUND;
-
-    return new Response(null, { status: 204 });
-  },
-};

routes/(apps)/notes/api/ues.ts

@@ -1,42 +0,0 @@
-import { Handlers } from "$fresh/server.ts";
-import { db } from "../../../../databases/db.ts";
-import { ues } from "../../../../databases/schema.ts";
-
-export const handler: Handlers = {
-  // #32 GET /ues
-  async GET() {
-    try {
-      const result = await db.select().from(ues);
-
-      return new Response(JSON.stringify(result), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error fetching UEs:", error);
-      return new Response("Failed to fetch data", { status: 500 });
-    }
-  },
-
-  // #33 POST /ues
-  async POST(request) {
-    try {
-      const body = await request.json();
-      const { nom } = body;
-
-      if (!nom) {
-        return new Response("Champ 'nom' manquant", { status: 400 });
-      }
-
-      const result = await db.insert(ues).values({ nom }).returning();
-
-      return new Response(JSON.stringify(result[0]), {
-        status: 201,
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error creating UE:", error);
-      return new Response("Failed to create UE", { status: 500 });
-    }
-  },
-};

routes/(apps)/notes/api/ues/[idUE].ts

@@ -1,122 +0,0 @@
-import { Handlers } from "$fresh/server.ts";
-import { db } from "../../../../../databases/db.ts";
-import { ues } from "../../../../../databases/schema.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-export const handler: Handlers = {
-  // # 34 GET /ues/:idUE
-  async GET(_request, context) {
-    try {
-      const idUE = parseInt(context.params.idUE);
-
-      if (isNaN(idUE)) {
-        return new Response(
-          JSON.stringify({ error: "Paramètre idUE invalide" }),
-          {
-            status: 400,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      const result = await db.select().from(ues).where(eq(ues.id, idUE));
-
-      if (result.length === 0) {
-        return new Response(
-          JSON.stringify({ error: "Ressource introuvable" }),
-          {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      return new Response(JSON.stringify(result[0]), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error fetching UE:", error);
-      return new Response("Failed to fetch data", { status: 500 });
-    }
-  },
-
-  // #35 PUT /ues/:idUE
-  async PUT(request, context) {
-    try {
-      const idUE = parseInt(context.params.idUE);
-
-      if (isNaN(idUE)) {
-        return new Response(
-          JSON.stringify({ error: "Paramètre idUE invalide" }),
-          {
-            status: 400,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      const body = await request.json();
-      const { nom } = body;
-
-      if (!nom) {
-        return new Response("Champ 'nom' manquant", { status: 400 });
-      }
-
-      const result = await db.update(ues).set({ nom }).where(eq(ues.id, idUE))
-        .returning();
-
-      if (result.length === 0) {
-        return new Response(
-          JSON.stringify({ error: "Ressource introuvable" }),
-          {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      return new Response(JSON.stringify(result[0]), {
-        status: 200,
-        headers: { "Content-Type": "application/json" },
-      });
-    } catch (error) {
-      console.error("Error updating UE:", error);
-      return new Response("Failed to update UE", { status: 500 });
-    }
-  },
-
-  // #36 DELETE /ues/:idUE
-  async DELETE(_request, context) {
-    try {
-      const idUE = parseInt(context.params.idUE);
-
-      if (isNaN(idUE)) {
-        return new Response(
-          JSON.stringify({ error: "Paramètre idUE invalide" }),
-          {
-            status: 400,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      const result = await db.delete(ues).where(eq(ues.id, idUE)).returning();
-
-      if (result.length === 0) {
-        return new Response(
-          JSON.stringify({ error: "Ressource introuvable" }),
-          {
-            status: 404,
-            headers: { "Content-Type": "application/json" },
-          },
-        );
-      }
-
-      return new Response(null, { status: 204 });
-    } catch (error) {
-      console.error("Error deleting UE:", error);
-      return new Response("Failed to delete UE", { status: 500 });
-    }
-  },
-};

routes/(apps)/students/api/promotions.ts

@@ -1,49 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { promotions } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #13 GET /promotions
-  async GET(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return new Response(JSON.stringify([]), {
-        headers: { "content-type": "application/json" },
-      });
-    }
-
-    const rows = await db.select().from(promotions);
-    return new Response(JSON.stringify(rows), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #14 POST /promotions
-  async POST(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return new Response(null, { status: 403 });
-    }
-
-    const body: { idPromo: string; annee: string } = await request.json();
-
-    if (!body.idPromo || !body.annee) {
-      return new Response(null, { status: 400 });
-    }
-
-    const [created] = await db
-      .insert(promotions)
-      .values({ id: body.idPromo, annee: body.annee })
-      .returning();
-
-    return new Response(JSON.stringify(created), {
-      status: 201,
-      headers: { "content-type": "application/json" },
-    });
-  },
-};

routes/(apps)/students/api/promotions/[idPromo].ts

@@ -1,79 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { promotions } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-const NOT_FOUND = new Response(
-  JSON.stringify({ error: "Ressource introuvable" }),
-  { status: 404, headers: { "content-type": "application/json" } },
-);
-
-const FORBIDDEN = new Response(null, { status: 403 });
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #15 GET /promotions/{idPromo}
-  async GET(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const promo = await db
-      .select()
-      .from(promotions)
-      .where(eq(promotions.id, context.params.idPromo))
-      .then((rows) => rows[0] ?? null);
-
-    if (!promo) return NOT_FOUND;
-
-    return new Response(JSON.stringify(promo), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #16 PUT /promotions/{idPromo}
-  async PUT(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const body: { annee: string } = await request.json();
-
-    const [updated] = await db
-      .update(promotions)
-      .set({ annee: body.annee })
-      .where(eq(promotions.id, context.params.idPromo))
-      .returning();
-
-    if (!updated) return NOT_FOUND;
-
-    return new Response(JSON.stringify(updated), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #17 DELETE /promotions/{idPromo}
-  async DELETE(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const [deleted] = await db
-      .delete(promotions)
-      .where(eq(promotions.id, context.params.idPromo))
-      .returning();
-
-    if (!deleted) return NOT_FOUND;
-
-    return new Response(null, { status: 204 });
-  },
-};

routes/(apps)/students/api/students.ts

@@ -1,61 +1,122 @@
 import { FreshContext, Handlers } from "$fresh/server.ts";
 import { db } from "$root/databases/db.ts";
-import { students } from "$root/databases/schema.ts";
+import { promotions, students } from "$root/databases/schema.ts";
 import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
+import { eq, lt } from "npm:drizzle-orm";
+
+async function getItself(
+  userId: string,
+): Promise<{ student: Student | null; promo: Promotion | null }> {
+  const student = await db
+    .select()
+    .from(students)
+    .where(eq(students.userId, userId))
+    .limit(1)
+    .then((rows) => rows[0] ?? null);
+
+  if (!student) {
+    return { student: null, promo: null };
+  }
+
+  const promo = await db
+    .select()
+    .from(promotions)
+    .where(eq(promotions.id, student.promotionId!))
+    .limit(1)
+    .then((rows) => rows[0] ?? null);
+
+  return { student, promo };
+}
+
+async function getAll(): Promise<
+  { students: Student[]; promos: Promotion[] }
+> {
+  const rows = await db
+    .select({
+      userId: students.userId,
+      firstName: students.firstName,
+      lastName: students.lastName,
+      mail: students.mail,
+      promotionId: students.promotionId,
+    })
+    .from(students)
+    .innerJoin(promotions, eq(students.promotionId, promotions.id))
+    .where(lt(promotions.current, 6));
+
+  const promos = await db
+    .select()
+    .from(promotions)
+    .where(lt(promotions.current, 6));
+
+  return { students: rows as Student[], promos };
+}
+
+async function addStudents(
+  studentList: Student[],
+  promoId: number,
+): Promise<void> {
+  for (const student of studentList) {
+    await db
+      .insert(students)
+      .values({
+        userId: student.userId,
+        firstName: student.firstName,
+        lastName: student.lastName,
+        mail: student.mail,
+        promotionId: promoId,
+      })
+      .onConflictDoNothing();
+  }
+}
 
 export const handler: Handlers<null, AuthenticatedState> = {
-  // #7 GET /students
   async GET(
-    request: Request,
+    _request: Request,
     context: FreshContext<AuthenticatedState>,
   ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
+    if (context.state.session.eduPersonPrimaryAffiliation == "student") {
-      return new Response(JSON.stringify([]), {
+      return new Response(
-        headers: { "content-type": "application/json" },
+        JSON.stringify(await getItself(context.state.session.uid)),
-      });
+        { headers: { "content-type": "application/json" } },
+      );
     }
 
-    const url = new URL(request.url);
+    return new Response(
-    const idPromo = url.searchParams.get("idPromo");
+      JSON.stringify(await getAll()),
-
+      { headers: { "content-type": "application/json" } },
-    const rows = idPromo
+    );
-      ? await db.select().from(students).where(eq(students.idPromo, idPromo))
-      : await db.select().from(students);
-
-    return new Response(JSON.stringify(rows), {
-      headers: { "content-type": "application/json" },
-    });
   },
 
-  // #8 POST /students
   async POST(
     request: Request,
-    context: FreshContext<AuthenticatedState>,
+    _context: FreshContext<AuthenticatedState>,
   ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
+    const { students: studentList, promo }: {
-      return new Response(null, { status: 403 });
+      students: Student[];
-    }
+      promo: string;
-
-    const body: {
-      numEtud: number;
-      nom: string;
-      prenom: string;
-      idPromo: string;
     } = await request.json();
 
-    if (!body.nom || !body.prenom || !body.idPromo) {
+    if (!promo || !promo.match(/^\d{4}-\dA$/) || !Array.isArray(studentList)) {
       return new Response(null, { status: 400 });
     }
 
-    const [created] = await db
+    const { endyear, current } = promo.match(
-      .insert(students)
+      /^(?<endyear>\d{4})-(?<current>\d)A$/,
-      .values({ nom: body.nom, prenom: body.prenom, idPromo: body.idPromo })
+    )?.groups!;
-      .returning();
 
-    return new Response(JSON.stringify(created), {
+    await db
-      status: 201,
+      .insert(promotions)
-      headers: { "content-type": "application/json" },
+      .values({ endyear: Number(endyear), current: Number(current) })
-    });
+      .onConflictDoNothing();
+
+    const promo_row = await db
+      .select()
+      .from(promotions)
+      .where(eq(promotions.endyear, Number(endyear)))
+      .then((rows) => rows.find((r) => r.current === Number(current))!);
+
+    await addStudents(studentList, promo_row.id);
+
+    return new Response(null, { status: 201 });
   },
 };

routes/(apps)/students/api/students/[numEtud].ts

@@ -1,83 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { students } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-const NOT_FOUND = new Response(
-  JSON.stringify({ error: "Ressource introuvable" }),
-  { status: 404, headers: { "content-type": "application/json" } },
-);
-
-const FORBIDDEN = new Response(null, { status: 403 });
-
-export const handler: Handlers<null, AuthenticatedState> = {
-  // #10 GET /students/{numEtud}
-  async GET(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const numEtud = Number(context.params.numEtud);
-    const student = await db
-      .select()
-      .from(students)
-      .where(eq(students.numEtud, numEtud))
-      .then((rows) => rows[0] ?? null);
-
-    if (!student) return NOT_FOUND;
-
-    return new Response(JSON.stringify(student), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #11 PUT /students/{numEtud}
-  async PUT(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const numEtud = Number(context.params.numEtud);
-    const body: { nom: string; prenom: string; idPromo: string } = await request
-      .json();
-
-    const [updated] = await db
-      .update(students)
-      .set({ nom: body.nom, prenom: body.prenom, idPromo: body.idPromo })
-      .where(eq(students.numEtud, numEtud))
-      .returning();
-
-    if (!updated) return NOT_FOUND;
-
-    return new Response(JSON.stringify(updated), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-
-  // #12 DELETE /students/{numEtud}
-  async DELETE(
-    _request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return FORBIDDEN;
-    }
-
-    const numEtud = Number(context.params.numEtud);
-    const [deleted] = await db
-      .delete(students)
-      .where(eq(students.numEtud, numEtud))
-      .returning();
-
-    if (!deleted) return NOT_FOUND;
-
-    return new Response(null, { status: 204 });
-  },
-};

routes/(apps)/students/api/students/import-csv.ts

@@ -1,64 +0,0 @@
-import { FreshContext, Handlers } from "$fresh/server.ts";
-import { db } from "$root/databases/db.ts";
-import { students } from "$root/databases/schema.ts";
-import { AuthenticatedState } from "$root/defaults/interfaces.ts";
-
-// #9 POST /students/import-csv
-export const handler: Handlers<null, AuthenticatedState> = {
-  async POST(
-    request: Request,
-    context: FreshContext<AuthenticatedState>,
-  ): Promise<Response> {
-    if (context.state.session.eduPersonPrimaryAffiliation !== "employee") {
-      return new Response(null, { status: 403 });
-    }
-
-    const formData = await request.formData();
-    const file = formData.get("file") as File | null;
-    const idPromo = formData.get("idPromo") as string | null;
-
-    if (!file || !idPromo) {
-      return new Response(null, { status: 400 });
-    }
-
-    const text = await file.text();
-    const lines = text.trim().split("\n");
-
-    let imported = 0;
-    const errors: { line: number; message: string }[] = [];
-
-    for (let i = 0; i < lines.length; i++) {
-      const lineNum = i + 1;
-      const cols = lines[i].split(",").map((c) => c.trim());
-
-      const [numEtudStr, nom, prenom] = cols;
-
-      if (!numEtudStr) {
-        errors.push({ line: lineNum, message: "Numéro étudiant manquant" });
-        continue;
-      }
-
-      const numEtud = Number(numEtudStr);
-      if (isNaN(numEtud)) {
-        errors.push({ line: lineNum, message: "Numéro étudiant invalide" });
-        continue;
-      }
-
-      if (!nom || !prenom) {
-        errors.push({ line: lineNum, message: "Nom ou prénom manquant" });
-        continue;
-      }
-
-      await db
-        .insert(students)
-        .values({ nom, prenom, idPromo })
-        .onConflictDoNothing();
-
-      imported++;
-    }
-
-    return new Response(JSON.stringify({ imported, errors }), {
-      headers: { "content-type": "application/json" },
-    });
-  },
-};

shell.nix

@@ -1,23 +0,0 @@
-{ pkgs ? import <nixpkgs> {} }:
-
-pkgs.mkShell {
-  name = "polympr-dev";
-  nativeBuildInputs = [
-    pkgs.deno
-    pkgs.patchelf
-    pkgs.tea
-  ];
-
-  buildInputs = [
-    pkgs.stdenv.cc.cc.lib
-  ];
-
-  shellHook = ''
-    export LD_LIBRARY_PATH="${pkgs.stdenv.cc.cc.lib}/lib:$LD_LIBRARY_PATH"
-    # Find the dynamic linker
-    export NIX_LD_INTERPRETER=$(cat ${pkgs.stdenv.cc}/nix-support/dynamic-linker)
-    echo "Welcome to PolyMPR development shell!"
-    echo "Use 'deno task compile' to build the CLI."
-    echo "If on NixOS, it will be automatically patched."
-  '';
-}

tests/e2e/users_test.ts

@@ -1,250 +0,0 @@
-// #111 - E2E tests for /users endpoints
-
-import { assertEquals, assertExists } from "@std/assert";
-import {
-  makeEmployeeContext,
-  makeGetRequest,
-  makeJsonRequest,
-} from "../helpers/handler.ts";
-import {
-  seedRoles,
-  seedUsers,
-  truncateAll,
-} from "../helpers/db_integration.ts";
-import { handler as usersHandler } from "$apps/admin/api/users.ts";
-import { handler as userHandler } from "$apps/admin/api/users/[id].ts";
-
-// --- GET /users ---
-
-Deno.test({
-  name: "e2e users: GET /users returns all users",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([
-      { id: "dupont.jean", nom: "Dupont", prenom: "Jean", idRole: role.id },
-      { id: "martin.alice", nom: "Martin", prenom: "Alice", idRole: role.id },
-    ]);
-    const res = await usersHandler.GET!(
-      makeGetRequest("/users"),
-      makeEmployeeContext(),
-    );
-    assertEquals(res.status, 200);
-    const body = await res.json();
-    assertEquals(body.length, 2);
-    assertExists(body.find((u: { id: string }) => u.id === "dupont.jean"));
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: GET /users?idRole filters by role",
-  async fn() {
-    await truncateAll();
-    const [role1] = await seedRoles([{ nom: "admin" }]);
-    const [role2] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([
-      { id: "u1", nom: "A", prenom: "A", idRole: role1.id },
-      { id: "u2", nom: "B", prenom: "B", idRole: role2.id },
-    ]);
-    const res = await usersHandler.GET!(
-      makeGetRequest("/users", { idRole: String(role1.id) }),
-      makeEmployeeContext(),
-    );
-    assertEquals(res.status, 200);
-    const body = await res.json();
-    assertEquals(body.length, 1);
-    assertEquals(body[0].id, "u1");
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-// --- POST /users ---
-
-Deno.test({
-  name: "e2e users: POST /users creates user (201)",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    const res = await usersHandler.POST!(
-      makeJsonRequest("/users", "POST", {
-        id: "nouveau.user",
-        nom: "Nouveau",
-        prenom: "User",
-        idRole: role.id,
-      }),
-      makeEmployeeContext(),
-    );
-    assertEquals(res.status, 201);
-    const body = await res.json();
-    assertEquals(body.id, "nouveau.user");
-    assertExists(body.nom);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: POST /users 409 on duplicate id",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "dup.user",
-      nom: "A",
-      prenom: "A",
-      idRole: role.id,
-    }]);
-    const res = await usersHandler.POST!(
-      makeJsonRequest("/users", "POST", {
-        id: "dup.user",
-        nom: "B",
-        prenom: "B",
-        idRole: role.id,
-      }),
-      makeEmployeeContext(),
-    );
-    assertEquals(res.status, 409);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: POST /users 400 on missing fields",
-  async fn() {
-    await truncateAll();
-    const res = await usersHandler.POST!(
-      makeJsonRequest("/users", "POST", { id: "x" }),
-      makeEmployeeContext(),
-    );
-    assertEquals(res.status, 400);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-// --- GET /users/:id ---
-
-Deno.test({
-  name: "e2e users: GET /users/:id returns user",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "test.user",
-      nom: "Test",
-      prenom: "User",
-      idRole: role.id,
-    }]);
-    const res = await userHandler.GET!(
-      makeGetRequest("/users/test.user"),
-      makeEmployeeContext({ id: "test.user" }),
-    );
-    assertEquals(res.status, 200);
-    const body = await res.json();
-    assertEquals(body.id, "test.user");
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: GET /users/:id 404 when not found",
-  async fn() {
-    await truncateAll();
-    const res = await userHandler.GET!(
-      makeGetRequest("/users/ghost"),
-      makeEmployeeContext({ id: "ghost" }),
-    );
-    assertEquals(res.status, 404);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-// --- PUT /users/:id ---
-
-Deno.test({
-  name: "e2e users: PUT /users/:id updates user",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "upd.user",
-      nom: "Old",
-      prenom: "Name",
-      idRole: role.id,
-    }]);
-    const res = await userHandler.PUT!(
-      makeJsonRequest("/users/upd.user", "PUT", {
-        nom: "New",
-        prenom: "Name",
-        idRole: role.id,
-      }),
-      makeEmployeeContext({ id: "upd.user" }),
-    );
-    assertEquals(res.status, 200);
-    const body = await res.json();
-    assertEquals(body.nom, "New");
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: PUT /users/:id 404 when not found",
-  async fn() {
-    await truncateAll();
-    const res = await userHandler.PUT!(
-      makeJsonRequest("/users/ghost", "PUT", {
-        nom: "X",
-        prenom: "Y",
-        idRole: 1,
-      }),
-      makeEmployeeContext({ id: "ghost" }),
-    );
-    assertEquals(res.status, 404);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-// --- DELETE /users/:id ---
-
-Deno.test({
-  name: "e2e users: DELETE /users/:id returns 204",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "del.user",
-      nom: "Del",
-      prenom: "Me",
-      idRole: role.id,
-    }]);
-    const res = await userHandler.DELETE!(
-      makeGetRequest("/users/del.user"),
-      makeEmployeeContext({ id: "del.user" }),
-    );
-    assertEquals(res.status, 204);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "e2e users: DELETE /users/:id 404 when not found",
-  async fn() {
-    await truncateAll();
-    const res = await userHandler.DELETE!(
-      makeGetRequest("/users/ghost"),
-      makeEmployeeContext({ id: "ghost" }),
-    );
-    assertEquals(res.status, 404);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});

tests/helpers/db_integration.ts

@@ -1,89 +0,0 @@
-// Helper pour les tests d'intégration avec PostgreSQL
-// Nécessite les variables d'environnement POSTGRES_* (ou TEST_DATABASE_URL)
-
-import { drizzle } from "npm:drizzle-orm@0.45.2/node-postgres";
-import pg from "npm:pg@8.20.0";
-import * as schema from "$root/databases/schema.ts";
-
-const { Pool } = pg;
-
-function createTestPool(): pg.Pool {
-  const url = Deno.env.get("TEST_DATABASE_URL");
-  if (url) {
-    return new Pool({ connectionString: url });
-  }
-  return new Pool({
-    host: Deno.env.get("POSTGRES_HOST") ?? "localhost",
-    port: Number(Deno.env.get("POSTGRES_PORT") ?? 5432),
-    user: Deno.env.get("POSTGRES_USER") ?? "test",
-    password: Deno.env.get("POSTGRES_PASS") ?? "test",
-    database: Deno.env.get("POSTGRES_DB") ?? "polympr_test",
-    ssl: false,
-  });
-}
-
-export const testPool = createTestPool();
-export const testDb = drizzle(testPool, { schema });
-
-const ALL_TABLES =
-  '"mobility","ajustements","notes","ue_modules","enseignements","role_permissions","students","users","modules","ues","promotions","permissions","roles"';
-
-/**
- * Vide toutes les tables dans le bon ordre.
- * À appeler dans beforeEach de chaque test d'intégration.
- */
-export async function truncateAll(): Promise<void> {
-  const client = await testPool.connect();
-  try {
-    await client.query(
-      `TRUNCATE TABLE ${ALL_TABLES} RESTART IDENTITY CASCADE`,
-    );
-  } finally {
-    client.release();
-  }
-}
-
-/**
- * Ferme le pool à la fin de la suite de tests.
- */
-export async function closeTestPool(): Promise<void> {
-  await testPool.end();
-}
-
-// --- Helpers d'insertion de fixtures ---
-
-export async function seedRoles(
-  rows: { nom: string }[],
-): Promise<typeof schema.roles.$inferSelect[]> {
-  return await testDb.insert(schema.roles).values(rows).returning();
-}
-
-export async function seedPromotions(
-  rows: { id: string; annee?: string }[],
-): Promise<typeof schema.promotions.$inferSelect[]> {
-  return await testDb.insert(schema.promotions).values(rows).returning();
-}
-
-export async function seedStudents(
-  rows: { nom: string; prenom: string; idPromo?: string }[],
-): Promise<typeof schema.students.$inferSelect[]> {
-  return await testDb.insert(schema.students).values(rows).returning();
-}
-
-export async function seedModules(
-  rows: { id: string; nom: string }[],
-): Promise<typeof schema.modules.$inferSelect[]> {
-  return await testDb.insert(schema.modules).values(rows).returning();
-}
-
-export async function seedUes(
-  rows: { nom: string }[],
-): Promise<typeof schema.ues.$inferSelect[]> {
-  return await testDb.insert(schema.ues).values(rows).returning();
-}
-
-export async function seedUsers(
-  rows: { id: string; nom: string; prenom: string; idRole?: number }[],
-): Promise<typeof schema.users.$inferSelect[]> {
-  return await testDb.insert(schema.users).values(rows).returning();
-}

tests/integration/users_test.ts

@@ -1,138 +0,0 @@
-// #111 - Integration tests for /users endpoints
-
-import { assertEquals, assertExists } from "@std/assert";
-import {
-  seedRoles,
-  seedUsers,
-  testDb,
-  truncateAll,
-} from "../helpers/db_integration.ts";
-import { users } from "$root/databases/schema.ts";
-import { eq } from "npm:drizzle-orm@0.45.2";
-
-Deno.test({
-  name: "integration users: list all users",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([
-      { id: "dupont.jean", nom: "Dupont", prenom: "Jean", idRole: role.id },
-      { id: "martin.alice", nom: "Martin", prenom: "Alice", idRole: role.id },
-    ]);
-    const rows = await testDb.select().from(users);
-    assertEquals(rows.length, 2);
-    assertExists(rows.find((u) => u.id === "dupont.jean"));
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "integration users: filter by idRole",
-  async fn() {
-    await truncateAll();
-    const [role1] = await seedRoles([{ nom: "admin" }]);
-    const [role2] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([
-      { id: "u1", nom: "A", prenom: "A", idRole: role1.id },
-      { id: "u2", nom: "B", prenom: "B", idRole: role2.id },
-    ]);
-    const rows = await testDb
-      .select()
-      .from(users)
-      .where(eq(users.idRole, role1.id));
-    assertEquals(rows.length, 1);
-    assertEquals(rows[0].id, "u1");
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "integration users: create and retrieve by id",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "admin" }]);
-    const [created] = await testDb
-      .insert(users)
-      .values({
-        id: "durand.claire",
-        nom: "Durand",
-        prenom: "Claire",
-        idRole: role.id,
-      })
-      .returning();
-    assertExists(created);
-    assertEquals(created.id, "durand.claire");
-
-    const row = await testDb
-      .select()
-      .from(users)
-      .where(eq(users.id, "durand.claire"))
-      .then((r) => r[0] ?? null);
-    assertExists(row);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "integration users: get by id returns null when not found",
-  async fn() {
-    await truncateAll();
-    const row = await testDb
-      .select()
-      .from(users)
-      .where(eq(users.id, "nonexistent"))
-      .then((r) => r[0] ?? null);
-    assertEquals(row, null);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "integration users: update user fields",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "test.user",
-      nom: "Test",
-      prenom: "User",
-      idRole: role.id,
-    }]);
-    const [updated] = await testDb
-      .update(users)
-      .set({ nom: "Updated", prenom: "Name" })
-      .where(eq(users.id, "test.user"))
-      .returning();
-    assertExists(updated);
-    assertEquals(updated.nom, "Updated");
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});
-
-Deno.test({
-  name: "integration users: delete user",
-  async fn() {
-    await truncateAll();
-    const [role] = await seedRoles([{ nom: "employee" }]);
-    await seedUsers([{
-      id: "to.delete",
-      nom: "Del",
-      prenom: "Me",
-      idRole: role.id,
-    }]);
-    await testDb.delete(users).where(eq(users.id, "to.delete"));
-    const row = await testDb
-      .select()
-      .from(users)
-      .where(eq(users.id, "to.delete"))
-      .then((r) => r[0] ?? null);
-    assertEquals(row, null);
-  },
-  sanitizeResources: false,
-  sanitizeOps: false,
-});

tests/unit/users_test.ts

@@ -1,216 +0,0 @@
-import { assertEquals } from "@std/assert";
-import { getFetchCalls, mockFetch, restoreFetch } from "../helpers/api_mock.ts";
-
-const BASE = "http://localhost/apps/admin/api/users";
-
-const users = [
-  { id: "dupont.jean", nom: "Dupont", prenom: "Jean", idRole: 1 },
-  { id: "martin.alice", nom: "Martin", prenom: "Alice", idRole: 2 },
-];
-
-// --- GET /users ---
-
-Deno.test("GET /users - returns all users", async () => {
-  mockFetch({ [BASE]: users });
-  try {
-    const res = await fetch(BASE);
-    assertEquals(res.status, 200);
-    const data = await res.json();
-    assertEquals(data.length, 2);
-    assertEquals(data[0].id, "dupont.jean");
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("GET /users - filters by idRole", async () => {
-  const filtered = users.filter((u) => u.idRole === 1);
-  mockFetch({ [`${BASE}?idRole=1`]: filtered });
-  try {
-    const res = await fetch(`${BASE}?idRole=1`);
-    assertEquals(res.status, 200);
-    const data = await res.json();
-    assertEquals(data.length, 1);
-    assertEquals(data[0].idRole, 1);
-  } finally {
-    restoreFetch();
-  }
-});
-
-// --- POST /users ---
-
-Deno.test("POST /users - creates a user and returns 201", async () => {
-  const newUser = {
-    id: "durand.claire",
-    nom: "Durand",
-    prenom: "Claire",
-    idRole: 1,
-  };
-  mockFetch({ [BASE]: { method: "POST", status: 201, body: newUser } });
-  try {
-    const res = await fetch(BASE, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(newUser),
-    });
-    assertEquals(res.status, 201);
-    const data = await res.json();
-    assertEquals(data.id, "durand.claire");
-    assertEquals(data.nom, "Durand");
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("POST /users - returns 409 on duplicate id", async () => {
-  mockFetch({
-    [BASE]: {
-      method: "POST",
-      status: 409,
-      body: { error: "Un utilisateur avec cet identifiant existe déjà" },
-    },
-  });
-  try {
-    const res = await fetch(BASE, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify(users[0]),
-    });
-    assertEquals(res.status, 409);
-    const data = await res.json();
-    assertEquals(typeof data.error, "string");
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("POST /users - returns 400 on missing fields", async () => {
-  mockFetch({ [BASE]: { method: "POST", status: 400 } });
-  try {
-    const res = await fetch(BASE, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ id: "x" }),
-    });
-    assertEquals(res.status, 400);
-  } finally {
-    restoreFetch();
-  }
-});
-
-// --- GET /users/{id} ---
-
-Deno.test("GET /users/{id} - returns a user by id", async () => {
-  mockFetch({ [`${BASE}/dupont.jean`]: users[0] });
-  try {
-    const res = await fetch(`${BASE}/dupont.jean`);
-    assertEquals(res.status, 200);
-    const data = await res.json();
-    assertEquals(data.id, "dupont.jean");
-    assertEquals(data.prenom, "Jean");
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("GET /users/{id} - returns 404 for unknown id", async () => {
-  mockFetch({
-    [`${BASE}/inconnu`]: {
-      status: 404,
-      body: { error: "Ressource introuvable" },
-    },
-  });
-  try {
-    const res = await fetch(`${BASE}/inconnu`);
-    assertEquals(res.status, 404);
-    const data = await res.json();
-    assertEquals(typeof data.error, "string");
-  } finally {
-    restoreFetch();
-  }
-});
-
-// --- PUT /users/{id} ---
-
-Deno.test("PUT /users/{id} - updates a user", async () => {
-  const updated = { ...users[0], prenom: "Jean-Pierre" };
-  mockFetch({
-    [`${BASE}/dupont.jean`]: { method: "PUT", status: 200, body: updated },
-  });
-  try {
-    const res = await fetch(`${BASE}/dupont.jean`, {
-      method: "PUT",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ nom: "Dupont", prenom: "Jean-Pierre", idRole: 1 }),
-    });
-    assertEquals(res.status, 200);
-    const data = await res.json();
-    assertEquals(data.prenom, "Jean-Pierre");
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("PUT /users/{id} - returns 404 for unknown id", async () => {
-  mockFetch({
-    [`${BASE}/inconnu`]: {
-      method: "PUT",
-      status: 404,
-      body: { error: "Ressource introuvable" },
-    },
-  });
-  try {
-    const res = await fetch(`${BASE}/inconnu`, {
-      method: "PUT",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ nom: "X", prenom: "Y", idRole: 1 }),
-    });
-    assertEquals(res.status, 404);
-  } finally {
-    restoreFetch();
-  }
-});
-
-// --- DELETE /users/{id} ---
-
-Deno.test("DELETE /users/{id} - deletes a user and returns 204", async () => {
-  mockFetch({
-    [`${BASE}/dupont.jean`]: { method: "DELETE", status: 204 },
-  });
-  try {
-    const res = await fetch(`${BASE}/dupont.jean`, { method: "DELETE" });
-    assertEquals(res.status, 204);
-  } finally {
-    restoreFetch();
-  }
-});
-
-Deno.test("DELETE /users/{id} - returns 404 for unknown id", async () => {
-  mockFetch({
-    [`${BASE}/inconnu`]: {
-      method: "DELETE",
-      status: 404,
-      body: { error: "Ressource introuvable" },
-    },
-  });
-  try {
-    const res = await fetch(`${BASE}/inconnu`, { method: "DELETE" });
-    assertEquals(res.status, 404);
-  } finally {
-    restoreFetch();
-  }
-});
-
-// --- getFetchCalls ---
-
-Deno.test("GET /users - call is tracked", async () => {
-  mockFetch({ [BASE]: users });
-  try {
-    await fetch(BASE);
-    const calls = getFetchCalls();
-    assertEquals(calls.length, 1);
-    assertEquals(calls[0].method, "GET");
-  } finally {
-    restoreFetch();
-  }
-});

toolbox/compile.sh

@@ -1,33 +0,0 @@
-#!/usr/bin/env bash
-set -e
-
-# Default output path
-OUTPUT_PATH="${HOME}/.deno/bin/pmpr"
-
-# Ensure directory exists
-mkdir -p "$(dirname "$OUTPUT_PATH")"
-
-# Check if we are on a system that needs patching (like NixOS)
-IS_NIXOS=false
-if [ "$(uname)" = "Linux" ]; then
-    if [ ! -f /lib64/ld-linux-x86-64.so.2 ] || ls -l /lib64/ld-linux-x86-64.so.2 | grep -q "stub-ld"; then
-        IS_NIXOS=true
-    fi
-fi
-
-if [ "$IS_NIXOS" = true ]; then
-    echo "NixOS detected. Creating a wrapper script instead of a compiled binary to avoid linking issues with Deno."
-    # Use absolute paths for config and script to make it work from anywhere
-    PROJECT_ROOT="$(pwd)"
-    cat > "$OUTPUT_PATH" <<EOF
-#!/usr/bin/env bash
-# PolyMPR CLI Wrapper for Nix
-exec deno run -A --config "$PROJECT_ROOT/deno.json" "$PROJECT_ROOT/toolbox/cli.ts" "\$@"
-EOF
-    chmod +x "$OUTPUT_PATH"
-    echo "Wrapper created at $OUTPUT_PATH"
-else
-    echo "Compiling CLI to $OUTPUT_PATH..."
-    deno compile -A --output "$OUTPUT_PATH" toolbox/cli.ts
-    echo "Done."
-fi