@mostajs/training 0.1.0

package/src/training.js

@@ -0,0 +1,61 @@
+// @mostajs/training — catalogue + sessions + inscriptions. Author: Dr Hamid MADANI <drmdh@msn.com>
+// Compose (injectés) : numbering (code session), notifications (ouverture/confirmation). Délègue éval/paiement/présence.
+
+export function createTraining({ repositories, numbering, notifications, now = () => new Date() } = {}) {
+  if (!repositories?.courses) throw new Error('createTraining: repositories requis');
+  const { courses, levels, sessions, enrollments } = repositories;
+  const confirmedCount = (sessionId) => enrollments.count((e) => e.sessionId === sessionId && e.status === 'confirmed');
+  const code = (course) => (numbering?.next ? numbering.next('session') : `${(course.title || 'SES').slice(0, 3).toUpperCase()}-${now().getFullYear()}-${Math.floor(now().getTime() % 100000)}`);
+
+  return {
+    catalog: {
+      createCourse: (dto) => courses.create({ active: true, ...dto }),
+      getCourse: (id) => courses.findById(id),
+      listCourses: (f = {}) => courses.find((c) => Object.entries(f).every(([k, v]) => c[k] === v)),
+      async addLevel(courseId, dto) { if (!(await courses.findById(courseId))) throw new Error('cours introuvable'); return levels.create({ courseId, ...dto }); },
+      listLevels: (courseId) => levels.find((l) => l.courseId === courseId).then((a) => a.sort((x, y) => x.order - y.order)),
+    },
+
+    sessions: {
+      async open(dto) {
+        const course = await courses.findById(dto.courseId); if (!course) throw new Error('cours introuvable');
+        const s = await sessions.create({ status: 'open', capacity: 0, ...dto, code: dto.code || code(course) });
+        notifications?.notify?.({ type: 'session.opened', sessionId: s.id });
+        return s;
+      },
+      get: (id) => sessions.findById(id),
+      listOpen: () => sessions.find((s) => s.status === 'open'),
+      setInstructor: (id, instructorId) => sessions.update(id, { instructorId }),
+      schedule: (id, { startDate, endDate, scheduleRef } = {}) => sessions.update(id, { startDate, endDate, scheduleRef }),
+      run: (id) => sessions.update(id, { status: 'running' }),
+      close: (id) => sessions.update(id, { status: 'closed' }),
+      async cancel(id) { const s = await sessions.update(id, { status: 'cancelled' }); notifications?.notify?.({ type: 'session.cancelled', sessionId: id }); return s; },
+    },
+
+    enrollments: {
+      async enroll(sessionId, learnerId) {
+        const s = await sessions.findById(sessionId); if (!s) throw new Error('session introuvable');
+        if (!['open', 'full'].includes(s.status)) throw new Error(`session non ouverte (${s.status})`);
+        const dup = (await enrollments.find((e) => e.sessionId === sessionId && e.learnerId === learnerId && e.status === 'confirmed'))[0];
+        if (dup) return dup;
+        if (s.capacity > 0 && (await confirmedCount(sessionId)) >= s.capacity) throw new Error('CapacityReached');
+        const e = await enrollments.create({ sessionId, learnerId, status: 'confirmed', enrolledAt: now() });
+        if (s.capacity > 0 && (await confirmedCount(sessionId)) >= s.capacity) await sessions.update(sessionId, { status: 'full' });
+        notifications?.notify?.({ type: 'enrollment.confirmed', sessionId, learnerId });
+        return e;
+      },
+      async cancel(enrollmentId) {
+        const e = await enrollments.update(enrollmentId, { status: 'cancelled' }); if (!e) return null;
+        const s = await sessions.findById(e.sessionId);
+        if (s && s.status === 'full') await sessions.update(s.id, { status: 'open' });
+        return e;
+      },
+      complete: (enrollmentId) => enrollments.update(enrollmentId, { status: 'completed' }),
+      listBySession: (sessionId) => enrollments.find((e) => e.sessionId === sessionId),
+      listByLearner: (learnerId) => enrollments.find((e) => e.learnerId === learnerId),
+      seats: async (sessionId) => { const s = await sessions.findById(sessionId); return { capacity: s.capacity, taken: await confirmedCount(sessionId) }; },
+    },
+
+    repositories,
+  };
+}

package/test-scripts/unit/training.test.mjs

@@ -0,0 +1,45 @@
+// @mostajs/training — tests (DEVRULES §5). node test-scripts/unit/training.test.mjs
+import assert from 'node:assert/strict';
+import { createTraining, createMemoryRepositories } from '../../src/index.js';
+let pass=0; const test=async(n,f)=>{await f();pass++;console.log('  ✓',n);};
+const mk=(o={})=>createTraining({ repositories:createMemoryRepositories(), ...o });
+
+await test('catalogue : cours + niveaux ordonnés', async()=>{
+  const t=mk(); const c=await t.catalog.createCourse({title:'Anglais',category:'langues'});
+  await t.catalog.addLevel(c.id,{order:2,label:'A2'}); await t.catalog.addLevel(c.id,{order:1,label:'A1'});
+  const ls=await t.catalog.listLevels(c.id); assert.deepEqual(ls.map(l=>l.label),['A1','A2']);
+});
+await test('session : open + code généré', async()=>{
+  const t=mk(); const c=await t.catalog.createCourse({title:'Mémoire'});
+  const s=await t.sessions.open({courseId:c.id, capacity:2});
+  assert.equal(s.status,'open'); assert.ok(s.code);
+});
+await test('inscription + contrôle de capacité (full)', async()=>{
+  const t=mk(); const c=await t.catalog.createCourse({title:'X'}); const s=await t.sessions.open({courseId:c.id,capacity:2});
+  await t.enrollments.enroll(s.id,'l1'); await t.enrollments.enroll(s.id,'l2');
+  assert.equal((await t.sessions.get(s.id)).status,'full');
+  await assert.rejects(()=>t.enrollments.enroll(s.id,'l3'), /CapacityReached/);
+});
+await test('annulation libère une place (full→open)', async()=>{
+  const t=mk(); const c=await t.catalog.createCourse({title:'X'}); const s=await t.sessions.open({courseId:c.id,capacity:1});
+  const e=await t.enrollments.enroll(s.id,'l1'); assert.equal((await t.sessions.get(s.id)).status,'full');
+  await t.enrollments.cancel(e.id); assert.equal((await t.sessions.get(s.id)).status,'open');
+});
+await test('inscription idempotente + listes', async()=>{
+  const t=mk(); const c=await t.catalog.createCourse({title:'X'}); const s=await t.sessions.open({courseId:c.id,capacity:0});
+  await t.enrollments.enroll(s.id,'l1'); await t.enrollments.enroll(s.id,'l1');
+  assert.equal((await t.enrollments.listBySession(s.id)).filter(e=>e.status==='confirmed').length,1);
+  assert.equal((await t.enrollments.listByLearner('l1')).length,1);
+});
+await test('refus inscription si session non ouverte', async()=>{
+  const t=mk(); const c=await t.catalog.createCourse({title:'X'}); const s=await t.sessions.open({courseId:c.id,capacity:5});
+  await t.sessions.cancel(s.id);
+  await assert.rejects(()=>t.enrollments.enroll(s.id,'l1'), /non ouverte/);
+});
+await test('notifications composées (ouverture/confirmation)', async()=>{
+  const ev=[]; const t=mk({ notifications:{ notify:(e)=>ev.push(e.type) } });
+  const c=await t.catalog.createCourse({title:'X'}); const s=await t.sessions.open({courseId:c.id,capacity:5});
+  await t.enrollments.enroll(s.id,'l1');
+  assert.ok(ev.includes('session.opened') && ev.includes('enrollment.confirmed'));
+});
+console.log(`\n✅ @mostajs/training — ${pass} tests OK`);