@mostajs/medical-cases 0.2.0

package/CHANGELOG.md

@@ -0,0 +1,30 @@
+# Changelog — @mostajs/medical-cases
+
+Format [Keep a Changelog](https://keepachangelog.com/fr/1.0.0/) · [SemVer](https://semver.org/lang/fr/).
+Auteur : Dr Hamid MADANI <drmdh@msn.com>
+
+## [0.2.0] — 2026-06-21
+
+### Added
+- **exams.cover** (prise en charge financière → status 'covered') — délègue à `@mostajs/aid-grants` (`aids.request`) si injecté, sinon référence fournie.
+- **exams.orient** ({centerName} → 'oriented') · **exams.schedule** ({slot}/`@mostajs/booking-stack` → 'scheduled', `bookingRef`).
+- **Codification CIM-10/CCAM de bout en bout** vérifiée en **intégration avec `@mostajs/nomenclature` réel** (`HEALTH_SEEDS`) : `diagnosis` (cim-10) et `exams.type` (ccam) validés/refusés (test `medical-cases-nomenclature.test.mjs`).
+- Tests : +1 unit (cover/orient/schedule, DI stubs) + 2 intégration nomenclature. Total **7 unit + 2 intégration verts**.
+
+## [0.1.0] — 2026-06-21
+
+### Added
+- Cœur métier MINCE **dossier patient + examens + circuit de prise en charge** (P3 Salsabil — patients cancer). Patron `@mostajs/incubator`/`advisory`.
+- `createMedicalCases({ repositories, nomenclature?, ged?, image?, statemachine?, booking?, aidGrants?, numbering?, audit?, now? })` — façade composant les capacités transverses par DI (aucune réimplémentation).
+- **cases** : `open` (patient + diagnostic CIM-10 optionnel), `get`/`list`/`listByStatus`, `advance` (circuit 9 étapes), `setStatus`, `close`.
+- **documents** : `add`/`list` (réf. `@mostajs/ged`).
+- **exams** : `request` (crée le bulletin), `get`/`listByCase`, `realize`, `result` (réf. ged).
+- **Codification optionnelle** : `diagnosis` validé en `cim-10` et `exams.request().type` en `ccam` si `@mostajs/nomenclature` injecté (seeder `HEALTH_SEEDS` — chacun son métier) ; sinon saisie libre.
+- `EXAM_CATEGORIES` (imaging/specialized/biology/anapath), `cycle` (9 étapes), `statusLabel` (7 statuts métier), `dashboard`, `reportingSource` (→ `@mostajs/reporting`).
+- Schémas `PatientCaseSchema`, `ExamSchema` + `createMemoryRepositories`.
+- **6 tests `@mostajs/mjs-unit`** + **exemple §12** (`examples/prise-en-charge`, parcours complet vérifié).
+- Proposition `docs/00-PROPOSITION-PLAN-MEDICAL-CASES-21062026.md` + livrables §9 #1–#3 (`docs/01..03`).
+
+### À venir
+- 0.2.0 : codification CIM/CCAM câblée bout-en-bout ; `exams.cover` (aid-grants) / `orient` / `schedule` (booking).
+- 1.0.0 : imagerie (image), export, i18n, 14 livrables + #15/#16 (DPIA secret médical) + #17.

package/README.md

@@ -0,0 +1,49 @@
+# @mostajs/medical-cases
+
+**Auteur** : Dr Hamid MADANI <drmdh@msn.com> · Licence : AGPL-3.0-or-later
+
+Cœur métier **mince** : **dossier patient + examens + circuit de prise en charge** (imagerie / biologie / anatomopathologie). DB-agnostique. **Compose** (jamais ne réimplémente) : `@mostajs/nomenclature` (diagnostic CIM-10 / examen CCAM), `@mostajs/ged` (documents), `@mostajs/image` (imagerie), `@mostajs/statemachine`, `@mostajs/booking-stack`, `@mostajs/aid-grants` (financement), `@mostajs/numbering`, `@mostajs/audit`.
+
+> Données de santé = **secret médical** : voir §11.3 (informatif) — base légale, minimisation, chiffrement au repos (`storage`), résidence pilotée par `.env`.
+
+## Install
+
+```bash
+npm i @mostajs/medical-cases
+```
+
+## Exemple minimal
+
+```js
+import { createMedicalCases, createMemoryRepositories } from '@mostajs/medical-cases';
+// Codification santé (chacun son métier) : injecter @mostajs/nomenclature seedé HEALTH_SEEDS.
+// import { createNomenclature, HEALTH_SEEDS } from '@mostajs/nomenclature';
+// const nomenclature = createNomenclature({ repositories, dataset: HEALTH_SEEDS, defaultScheme: 'cim-10' });
+
+const m = createMedicalCases({ repositories: createMemoryRepositories() /*, nomenclature, ged, aidGrants, booking */ });
+
+const c = await m.cases.open({ patient: { name: 'Fatima Z.' }, diagnosis: 'C50', physician: 'Dr Benali', facility: 'CAC' });
+await m.documents.add(c.id, { gedDocId: 'ged-cr-001', kind: 'CR' });
+const e = await m.exams.request(c.id, { type: 'IMG-TDM', category: 'imaging' }); // crée le bulletin
+await m.exams.realize(e.id);
+await m.exams.result(e.id, { gedDocId: 'ged-res-001' });
+await m.cases.advance(c.id); // circuit de prise en charge (9 étapes → clôture)
+```
+
+## API (0.1.0)
+
+- `createMedicalCases({ repositories, nomenclature?, ged?, image?, statemachine?, booking?, aidGrants?, numbering?, audit?, now? })`
+- **cases** : `open({patient,diagnosis?,physician?,facility?,caregiver?})` · `get` · `list(filter)` · `listByStatus(s)` · `advance(id)` · `setStatus(id,s)` · `close(id,{outcome})`
+- **documents** : `add(id,{gedDocId,kind?,label?})` · `list(id)`
+- **exams** : `request(caseId,{type,category?})` (→ bulletin) · `get` · `listByCase` · `realize(examId)` · `result(examId,{gedDocId})`
+- **dashboard()** · **reportingSource()** (→ `@mostajs/reporting`)
+- `cycle` (9 étapes) · `categories` (= `EXAM_CATEGORIES`) · `statusLabel(s)` (7 statuts métier)
+- `createMemoryRepositories()` · `PatientCaseSchema`, `ExamSchema`
+
+## Codification (composer `@mostajs/nomenclature`)
+
+Si `nomenclature` est injecté, `diagnosis` est validé en **`cim-10`** et `exams.request().type` en **`ccam`** (sinon saisie libre — dégradation gracieuse). Côté app santé : seeder `HEALTH_SEEDS`.
+
+## Tests & exemple
+
+`npm test` (`@mostajs/mjs-unit`, 6 tests) · `npm run example` (parcours de prise en charge, assertions).

package/llms.txt

@@ -0,0 +1,48 @@
+# @mostajs/medical-cases — llms.txt
+
+RÔLE
+  Cœur métier MINCE : dossier patient + examens + circuit de prise en charge (imagerie/biologie/anatomopathologie).
+  Responsabilité UNIQUE : le domaine médical (patient, examens, PEC). AUCUNE capacité transverse réimplémentée.
+  Consommateur : associations d'aide aux malades / centres de prise en charge (P3 Salsabil — patients cancer).
+  Données de SANTÉ → secret médical (DEVRULES §11.3 informatif au déploiement).
+
+COMPOSE (injection de dépendances, toutes optionnelles sauf repositories)
+  repositories  OBLIGATOIRE — { cases, exams }. createMemoryRepositories() pour tests ; @mostajs/orm en prod.
+  nomenclature  @mostajs/nomenclature — validation diagnostic (scheme 'cim-10') + type d'examen (scheme 'ccam').
+                Côté app santé : seeder HEALTH_SEEDS. Si absent → saisie libre (dégradation gracieuse).
+  ged           @mostajs/ged — documents (CR, ordonnances, résultats). Réf. gedDocId seulement.
+  image         @mostajs/image — imagerie (vignettes/EXIF) [0.3.0].
+  statemachine  @mostajs/statemachine — moteur du circuit (en interne : cycle 9 étapes).
+  booking       @mostajs/booking-stack — programmation d'examen / RDV [0.2.0].
+  aidGrants     @mostajs/aid-grants — financement (prise en charge) de l'examen [0.2.0].
+  numbering     @mostajs/numbering — n° dossier (MED-…) + bulletin (EXA-…).
+  audit         @mostajs/audit — journal (traçabilité, secret médical).
+  HORS PÉRIMÈTRE : aides (aid-grants), documents (ged), RDV (booking), reporting (reporting), donateurs (donors).
+
+EXPORTS (src/index.js)
+  createMedicalCases({ repositories, nomenclature?, ged?, image?, statemachine?, booking?, aidGrants?, numbering?, audit?, now? }) -> api
+  createMemoryRepositories() -> { cases, exams }
+  EXAM_CATEGORIES = ['imaging','specialized','biology','anapath']
+  PatientCaseSchema, ExamSchema (./schemas)
+
+API
+  cases.open({patient{name,...}, diagnosis?(cim-10), physician?, facility?, caregiver?}) -> case (status 'requested')
+  cases.get/list(filter)/listByStatus(s) ; cases.advance(id) ; cases.setStatus(id,s) ; cases.close(id,{outcome})
+  documents.add(id,{gedDocId,kind?,label?}) ; documents.list(id)
+  exams.request(caseId,{type(ccam),category?}) -> exam (status 'bulletin', bulletinNo) ; exams.get/listByCase
+  exams.cover(examId,{grantRef?|amount,budgetLine?,type?}) -> 'covered' (délègue aid-grants.aids.request si injecté)
+  exams.orient(examId,{centerName}) -> 'oriented' ; exams.schedule(examId,{slot,bookingRef?}) -> 'scheduled' (délègue booking si injecté)
+  exams.realize(examId) ; exams.result(examId,{gedDocId})
+  dashboard() -> {total,enCours,clotures} ; reportingSource() -> () => cases[]
+  cycle (9): requested→bulletin→studying→covered→oriented→realized→results→archived→closed
+  statusLabel(s) -> 7 statuts métier spec ; categories = EXAM_CATEGORIES
+
+PIÈGES
+  - repositories.cases ET repositories.exams requis.
+  - diagnosis/type validés UNIQUEMENT si nomenclature injecté (sinon stockés tels quels).
+  - Codes nomenclature normalisés sans points (C50.9→C509) — voir @mostajs/nomenclature.
+  - Le module ne porte PAS aides/documents/RDV/reporting : il les COMPOSE.
+
+VERSIONS
+  0.1.0 : dossier + circuit + documents + exams.request/realize/result + dashboard + reportingSource (6 tests, exemple).
+  0.2.0 (prévu) : codification cim-10/ccam câblée + exams.cover(aid-grants)/orient/schedule(booking).

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@mostajs/medical-cases",
+  "version": "0.2.0",
+  "description": "Cœur métier MINCE de dossier patient + examens + circuit de prise en charge (imagerie/biologie/anapath). DB-agnostique ; COMPOSE nomenclature (cim-10/ccam), ged, image, statemachine, booking, aid-grants, numbering, audit. Générique santé (P3 Salsabil).",
+  "license": "AGPL-3.0-or-later",
+  "author": "Dr Hamid MADANI <drmdh@msn.com>",
+  "type": "module",
+  "main": "src/index.js",
+  "files": [
+    "src",
+    "llms.txt",
+    "README.md",
+    "CHANGELOG.md"
+  ],
+  "exports": {
+    ".": "./src/index.js",
+    "./schemas": "./src/schemas.js"
+  },
+  "keywords": [
+    "mostajs",
+    "medical",
+    "dossier-patient",
+    "prise-en-charge",
+    "examens",
+    "imagerie",
+    "anapath",
+    "cim-10",
+    "ccam",
+    "sante",
+    "salsabil"
+  ],
+  "devDependencies": {
+    "@mostajs/mjs-unit": "^0.3.0"
+  },
+  "scripts": {
+    "test": "bash test-scripts/run-tests.sh",
+    "example": "node examples/prise-en-charge/run.mjs"
+  }
+}

package/src/index.js

@@ -0,0 +1,4 @@
+// @mostajs/medical-cases — point d'entrée. Author: Dr Hamid MADANI <drmdh@msn.com>
+export { createMedicalCases, EXAM_CATEGORIES } from './medical-cases.js';
+export { createMemoryRepositories } from './memory-repo.js';
+export { PatientCaseSchema, ExamSchema } from './schemas.js';

package/src/medical-cases.js

@@ -0,0 +1,120 @@
+// @mostajs/medical-cases — cœur métier MINCE : dossier patient + examens + circuit de prise en charge. Author: Dr Hamid MADANI <drmdh@msn.com>
+// N'implémente QUE le domaine médical (patient + examens + PEC). COMPOSE (injecté, optionnel) :
+//   nomenclature (cim-10 diagnostic / ccam examen), ged (documents), image (imagerie), statemachine, booking (programmation),
+//   aid-grants (financement), numbering (n° dossier/bulletin), audit. Secret médical → §11.3 (informatif) au déploiement.
+
+// Circuit de prise en charge (9 étapes spec) :
+const CYCLE = ['requested', 'bulletin', 'studying', 'covered', 'oriented', 'realized', 'results', 'archived', 'closed'];
+// Correspondance informative vers les 7 statuts métier de la spec :
+const STATUS_LABEL = {
+  requested: "en cours d'étude", bulletin: 'en attente de validation', studying: "en cours d'étude",
+  covered: 'prise en charge accordée', oriented: 'examen programmé', realized: 'examen réalisé',
+  results: 'résultats reçus', archived: 'résultats reçus', closed: 'dossier clôturé',
+};
+export const EXAM_CATEGORIES = ['imaging', 'specialized', 'biology', 'anapath'];
+
+export function createMedicalCases({ repositories, ged, image, nomenclature, statemachine, booking, aidGrants, numbering, audit, now = () => new Date() } = {}) {
+  if (!repositories?.cases) throw new Error('createMedicalCases: repositories.cases requis');
+  if (!repositories?.exams) throw new Error('createMedicalCases: repositories.exams requis');
+  const { cases, exams } = repositories;
+  const caseNo = () => (numbering?.next ? numbering.next('medical-case') : `MED-${now().getFullYear()}-${String(Math.floor(now().getTime() % 100000)).padStart(5, '0')}`);
+  const bulletinNo = () => (numbering?.next ? numbering.next('exam-bulletin') : `EXA-${now().getFullYear()}-${String(Math.floor(now().getTime() % 100000)).padStart(5, '0')}`);
+  const trace = (type, data) => { audit?.log?.({ type, ...data, at: now() }); };
+
+  // Validation codifiée OPTIONNELLE (chacun dans son métier : nomenclature seedée HEALTH_SEEDS côté app santé).
+  const validateCode = async (code, scheme) => {
+    if (!code || !nomenclature?.codes?.validate) return code || null;
+    const v = await nomenclature.codes.validate(code, { scheme });
+    if (!v.ok) throw new Error(`code ${scheme} invalide: ${code}`);
+    return v.normalized || code;
+  };
+
+  const api = {
+    cycle: CYCLE, categories: EXAM_CATEGORIES, statusLabel: (s) => STATUS_LABEL[s] || s,
+
+    cases: {
+      /** Ouvre un dossier patient (status 'requested'). `diagnosis` = code CIM-10 (validé si nomenclature injectée). */
+      async open({ patient, diagnosis, physician, facility, caregiver } = {}) {
+        if (!patient?.name) throw new Error('medical.open: patient.name requis');
+        const dx = await validateCode(diagnosis, 'cim-10');
+        const r = await cases.create({ no: caseNo(), patient, diagnosis: dx, physician: physician || null, facility: facility || null, caregiver: caregiver || null, status: 'requested', documents: [] });
+        trace('medical.opened', { caseId: r.id }); return r;
+      },
+      get: (id) => cases.findById(id),
+      list: (f = {}) => cases.find((r) => Object.entries(f).every(([k, v]) => r[k] === v)),
+      listByStatus: (s) => cases.find((r) => r.status === s),
+      /** Avance d'une étape dans le circuit de prise en charge. */
+      async advance(id) {
+        const r = await cases.findById(id); if (!r) throw new Error('dossier introuvable');
+        const i = CYCLE.indexOf(r.status);
+        if (i < 0 || i >= CYCLE.length - 1) throw new Error(`transition impossible depuis '${r.status}'`);
+        const status = CYCLE[i + 1]; const patch = { status }; if (status === 'closed') patch.closedAt = now();
+        const u = await cases.update(id, patch); trace('medical.advanced', { caseId: id, status }); return u;
+      },
+      setStatus: async (id, status) => { if (!CYCLE.includes(status)) throw new Error('statut inconnu'); return cases.update(id, { status }); },
+      async close(id, { outcome } = {}) { const u = await cases.update(id, { status: 'closed', outcome: outcome || null, closedAt: now() }); trace('medical.closed', { caseId: id }); return u; },
+    },
+
+    documents: {
+      /** Rattache un document @mostajs/ged (CR, ordonnance, résultat, imagerie). Les octets restent dans ged. */
+      async add(id, { gedDocId, kind, label } = {}) {
+        const r = await cases.findById(id); if (!r) throw new Error('dossier introuvable');
+        if (!gedDocId) throw new Error('documents.add: gedDocId requis');
+        const documents = [...(r.documents || []), { gedDocId, kind: kind || null, label: label || null }];
+        return cases.update(id, { documents });
+      },
+      list: async (id) => { const r = await cases.findById(id); return r?.documents || []; },
+    },
+
+    exams: {
+      /** Demande un examen → crée le bulletin (status 'bulletin'). `type` = code CCAM (validé si nomenclature injectée). */
+      async request(caseId, { type, category } = {}) {
+        const r = await cases.findById(caseId); if (!r) throw new Error('dossier introuvable');
+        if (!type) throw new Error('exams.request: type requis');
+        if (category && !EXAM_CATEGORIES.includes(category)) throw new Error(`catégorie inconnue: ${category}`);
+        const t = await validateCode(type, 'ccam');
+        const e = await exams.create({ caseId, type: t, category: category || null, status: 'bulletin', bulletinNo: bulletinNo(), centerName: null, grantRef: null, bookingRef: null, resultDocId: null });
+        trace('exam.requested', { examId: e.id, caseId, type: t }); return e;
+      },
+      get: (examId) => exams.findById(examId),
+      listByCase: (caseId) => exams.find((e) => e.caseId === caseId),
+      /** Prise en charge financière de l'examen → status 'covered'. Délègue à @mostajs/aid-grants si injecté (sinon réf. fournie). */
+      async cover(examId, { grantRef, amount = 0, budgetLine, type = 'medicale' } = {}) {
+        const e = await exams.findById(examId); if (!e) throw new Error('examen introuvable');
+        let ref = grantRef || null;
+        if (!ref && aidGrants?.aids?.request) {
+          const aid = await aidGrants.aids.request(e.caseId, { type, amount, note: `Examen ${e.type} (${e.bulletinNo})`, budgetLine: budgetLine || null });
+          ref = aid?.ref || aid?.id || null;
+        }
+        const u = await exams.update(examId, { status: 'covered', grantRef: ref }); trace('exam.covered', { examId, grantRef: ref }); return u;
+      },
+      /** Orientation vers le centre de réalisation → status 'oriented'. */
+      async orient(examId, { centerName } = {}) {
+        const e = await exams.findById(examId); if (!e) throw new Error('examen introuvable');
+        if (!centerName) throw new Error('exams.orient: centerName requis');
+        return exams.update(examId, { status: 'oriented', centerName });
+      },
+      /** Programmation de l'examen → status 'scheduled'. Délègue à @mostajs/booking-stack si injecté (sinon réf./slot fournis). */
+      async schedule(examId, { slot, bookingRef } = {}) {
+        const e = await exams.findById(examId); if (!e) throw new Error('examen introuvable');
+        let ref = bookingRef || null;
+        if (!ref && booking?.book) { const b = await booking.book({ ref: e.bulletinNo, slot }); ref = b?.id || b?.ref || null; }
+        const u = await exams.update(examId, { status: 'scheduled', bookingRef: ref, slot: slot || null }); trace('exam.scheduled', { examId, bookingRef: ref }); return u;
+      },
+      /** Marque l'examen réalisé. */
+      async realize(examId) { const e = await exams.findById(examId); if (!e) throw new Error('examen introuvable'); return exams.update(examId, { status: 'realized', realizedAt: now() }); },
+      /** Enregistre le résultat (réf. document ged) → status 'results'. */
+      async result(examId, { gedDocId } = {}) { const e = await exams.findById(examId); if (!e) throw new Error('examen introuvable'); if (!gedDocId) throw new Error('exams.result: gedDocId requis'); return exams.update(examId, { status: 'results', resultDocId: gedDocId }); },
+    },
+
+    async dashboard() {
+      const all = await cases.find();
+      const by = (s) => all.filter((r) => r.status === s).length;
+      return { total: all.length, enCours: all.filter((r) => r.status !== 'closed').length, clotures: by('closed') };
+    },
+    /** Source pour @mostajs/reporting. */
+    reportingSource() { return async () => cases.find(); },
+    repositories,
+  };
+  return api;
+}

package/src/memory-repo.js

@@ -0,0 +1,7 @@
+// @mostajs/medical-cases — repos in-mem pour tests/exemples (DB réelle via @mostajs/orm au déploiement). Author: Dr Hamid MADANI <drmdh@msn.com>
+function coll() { const m = new Map(); return {
+  async create(d) { const id = d.id || globalThis.crypto.randomUUID(); const now = new Date(); const r = { id, createdAt: now, updatedAt: now, ...d }; m.set(id, r); return { ...r }; },
+  async findById(id) { const r = m.get(id); return r ? { ...r } : null; },
+  async update(id, p) { const r = m.get(id); if (!r) return null; const x = { ...r, ...p, updatedAt: new Date() }; m.set(id, x); return { ...x }; },
+  async find(f = () => true) { return [...m.values()].filter(f).map((r) => ({ ...r })); } }; }
+export function createMemoryRepositories() { return { cases: coll(), exams: coll() }; }

package/src/schemas.js

@@ -0,0 +1,29 @@
+// @mostajs/medical-cases — schémas minces (dossier patient + examen). Author: Dr Hamid MADANI <drmdh@msn.com>
+// Le patient est porté ici (assoc. d'aide aux malades) ; documents/imagerie → @mostajs/ged/@mostajs/image (réf. seulement) ;
+// diagnostic (cim-10) & type d'examen (ccam) → @mostajs/nomenclature (codes seulement) ; financement → @mostajs/aid-grants (réf.).
+
+export const PatientCaseSchema = { name: 'PatientCase', collection: 'medical_cases', timestamps: true, fields: {
+  no: { type: 'string' },                                   // → @mostajs/numbering (MED-2026-…)
+  patient: { type: 'json', required: true },                // { name, birthDate?, phone?, address? } — secret médical (§11.3)
+  diagnosis: { type: 'string', default: null },             // code CIM-10 → @mostajs/nomenclature (scheme 'cim-10')
+  physician: { type: 'string', default: null },             // médecin traitant
+  facility: { type: 'string', default: null },              // établissement de suivi
+  caregiver: { type: 'string', default: null },             // accompagnateur / tuteur
+  status: { type: 'string', enum: ['requested','bulletin','studying','covered','oriented','realized','results','archived','closed'], default: 'requested' },
+  documents: { type: 'array', default: [] },                // [{ gedDocId, kind, label }] réf. @mostajs/ged
+  outcome: { type: 'string', default: null },
+  closedAt: { type: 'date', default: null } },
+  indexes: [{ fields: { status: 'asc' } }] };
+
+export const ExamSchema = { name: 'Exam', collection: 'medical_exams', timestamps: true, fields: {
+  caseId: { type: 'string', required: true },               // → PatientCase
+  type: { type: 'string', required: true },                 // code CCAM → @mostajs/nomenclature (scheme 'ccam')
+  category: { type: 'string', enum: ['imaging','specialized','biology','anapath'], default: null },
+  status: { type: 'string', enum: ['bulletin','covered','oriented','scheduled','realized','results'], default: 'bulletin' },
+  bulletinNo: { type: 'string' },                           // → @mostajs/numbering (EXA-2026-…)
+  centerName: { type: 'string', default: null },            // centre de réalisation (orientation)
+  grantRef: { type: 'string', default: null },              // → @mostajs/aid-grants (prise en charge financière)
+  bookingRef: { type: 'string', default: null },            // → @mostajs/booking-stack (programmation)
+  resultDocId: { type: 'string', default: null },           // → @mostajs/ged (résultats)
+  realizedAt: { type: 'date', default: null } },
+  indexes: [{ fields: { caseId: 'asc' } }] };