Audit de conformite — Modules BackEnd vs Guide Architecture DDD¶

Date : 2026-06-15 Reference : 1_GUIDE_ARCHITECTURE_DDD.md (29 regles absolues) Auditeur : Claude Code automatique Perimetre : 17 modules BackEnd

Synthese executive¶

Module	Statut	Violations critiques	Warnings
Accompagnements	CONFORME	0	1
Administration	CONFORME	0	1
Audit	CONFORME	0	1
Auth	PARTIEL	2	2
Enfants	PARTIEL	1	1
Evaluations	CONFORME	0	1
Formations	CONFORME	0	1
ImportExcel	CONFORME	0	0
Insertion	CONFORME	0	1
MaitresCoraniques	CONFORME	0	1
Mobilisation	PARTIEL	2	1
Parents	PARTIEL	1	0
Pilotage	PARTIEL	1	1
Rapports	CONFORME	0	1
Referentiels	PARTIEL	1	0
Synchronisation	CONFORME	0	1
Tuteurs	CONFORME	0	1

Score global¶

10/17 conformes | 6/17 partiels | 1/17 non conformes

Violations critiques totales : 8 Warnings totaux : 13

Detail par module¶

1. Accompagnements — CONFORME¶

Points conformes¶

Structure 5 couches complete (domain, application, infrastructure, interface-adapters, index.ts)
Exceptions : ErreurAccompagnement extends ErreurMetier + this.name + captureStackTrace
domain/schemas/ : constantes string uniquement (schemaCreerAccompagnement = 'creerAccompagnement', etc.)
Pattern 5 etapes use cases : validerAvecReglesMetier + executerLogique + auditer + construireResultat + gererErreur
Repos Prisma : updateMany/deleteMany + idUtilisateur dans WHERE + mapper prive
Handlers : extends BaseActionHandler + getActionName + executeBusinessLogic
ModuleController : arrow functions, pas de req.user detecte
Routes : statiques avant dynamiques (/ avant /:id) ; routes imbriquees /:id/suivis apres /
Regle 7 : aucun z.string().uuid()
Regle 22 : aucun .then()
Regle 21 : imports @/ predominants (quelques ../ internes normalises)
Regle 1 : PrismaClient absent de la couche application

Warnings¶

W1 : La methode construireResultat() reçoit le resultat brut du repository (DTO) plutot que l'entite Accompagnement — l'entite a bien versObjetPlainPublic() mais executerLogique() retourne directement le DTO du repository. Cela court-circuite la regle 14 (construireResultat doit appeler versObjetPlainPublic sur l'entite). Impact : minime car le DTO du repo est identique a ce que retournerait versObjetPlainPublic().

2. Administration — CONFORME¶

Points conformes¶

Structure 5 couches complete
Exceptions : ErreurAdministration extends ErreurMetier + this.name + captureStackTrace (with guard if Error.captureStackTrace)
Interfaces use case : executer(), succes + message, CodeErreur type union
Pattern 5 etapes present dans les use cases
ServiceValidationAdministration dans infrastructure/services/validation/
DI module : AdministrationModule extends DIModule
ModuleController : arrow functions
Regle 7, 22, 1 : conformes

Warnings¶

W1 : Module non-multi-tenant (pas d'idUtilisateur dans les WHERE des repositories), ce qui est conforme au besoin metier (Admin gere tous les utilisateurs), mais il n'existe pas de doctrine explicite documentee dans le module pour l'exclure de la contrainte multi-tenant.

3. Audit — CONFORME¶

Points conformes¶

Structure 5 couches complete (2 use cases : ListerLogs + ObtenirLog)
Exceptions : ErreurAudit extends ErreurMetier + this.name + captureStackTrace
Interfaces use case conformes (executer, succes + message, CodeErreur)
ServiceValidationAudit present
Handlers : extends BaseActionHandler
DI : AuditModule extends DIModule
Routes auto-discovery presentes
Module lecture seule (pas d'ecriture, pas besoin de updateMany/deleteMany)

Warnings¶

W1 : Domain/schemas/audit.schemas.ts a verifier que toutes les constantes Zod sont bien dans infrastructure/schemas/zod/ (architecture 2 niveaux). Difficulte a valider sans lire le fichier entier.

4. Auth — PARTIEL¶

Violations critiques¶

VIOLATION Regle 15 / Architecture — Le fichier de routes auto-discovery est situe dans shared/infrastructure/http/routes/auth.module.routes.ts au lieu de Modules/Auth/infrastructure/http/routes/auth.module.routes.ts. Chaque module doit avoir ses propres routes dans son propre dossier d'infrastructure. Les routes Auth sont dans shared/ ce qui est une violation du principe d'encapsulation modulaire.
VIOLATION Regle Guide Phase 7 — IServiceValidation est dupliquee : Auth a sa propre interface Modules/Auth/domain/interfaces/services/IServiceValidation.ts en plus de shared/domain/interfaces/services/IServiceValidation.ts. Le guide specifie "une seule fois pour tout le projet". La duplication peut entraîner des divergences si les deux interfaces evoluent separement.

Points conformes¶

Exceptions : 8 classes (ErreurConnexion, ErreurInscription, etc.) toutes extends ErreurMetier + this.name + captureStackTrace
Handlers : tous extends BaseActionHandler (ConnexionHandler, VerifierEmailHandler, etc.)
Use cases 5 etapes : validerAvecReglesMetier appele (via ServiceValidationAuth)
28 interfaces use case + 28 implementations (couverture tres complete)
Repositories Prisma : multiples repos speciialises (Utilisateur, Session, BackupCode, etc.)
ModuleController : AuthModuleController avec arrow functions
Regle 7, 22, 1 : conformes

Warnings¶

W1 : InscrireUtilisateur.ts et InscrireUtilisateurUseCase.ts coexistent (l'un est un re-export de l'autre) — doublon justifie par compatibilite ascendante mais a nettoyer.
W2 : SessionAuthRepositoryPrisma utilise .update() (pas .updateMany()) pour des mises a jour de sessions. Auth etant non-multi-tenant (les sessions ne sont pas filtrees par idUtilisateur dans ce contexte), la justification est acceptable, mais devrait etre documentee.

5. Enfants — PARTIEL¶

Violations critiques¶

VIOLATION Regle 14 — Dans CreerEnfantUseCase.ts, executerLogique() retourne directement le DTO du repository (pas l'entite Enfant), donc construireResultat() ne peut pas appeler versObjetPlainPublic() sur une entite. L'entite Enfant a pourtant la methode versObjetPlainPublic() implementee. Le pattern correct serait : executerLogique() retourne Enfant (entite domain) → construireResultat() appelle enfant.versObjetPlainPublic(). Ce pattern est viole dans CreerEnfantUseCase, ModifierEnfantUseCase, et ChangerStatutEnfantUseCase.

Points conformes¶

Structure 5 couches complete
Exceptions : ErreurEnfant extends ErreurMetier + this.name + captureStackTrace
ServiceValidationEnfants present
Interfaces use case : executer(), succes + message, CodeErreur
Handlers : extends BaseActionHandler
ModuleController : arrow functions
Entite Enfant : versObjetPlainPublic() et versObjetPlain() implementees
Regle 7, 22, 1, 21 : conformes

Warnings¶

W1 : Meme pattern de violation dans ListerEnfantsUseCase — executerLogique() retourne la liste brute du repository au lieu de la reconstruire via les entites.

6. Evaluations — CONFORME¶

Points conformes¶

Structure 5 couches complete (+ domain/services/CalculEvaluation.ts)
Exceptions : ErreurEvaluation extends ErreurMetier + this.name + captureStackTrace
Entite Evaluation : versObjetPlain() + versObjetPlainPublic() implementees
Interfaces use case conformes
ServiceValidationEvaluations present
Handlers : extends BaseActionHandler
Repos : mapper() prive present
Regle 7, 22, 1, 21 : conformes

Warnings¶

W1 : Meme pattern potential de violation regle 14 (executerLogique peut retourner DTO vs entite) — a verifier dans CreerEvaluationUseCase.

7. Formations — CONFORME¶

Points conformes¶

Structure 5 couches (le plus complet : 26 use cases, 5 repositories, 4 exceptions typees)
Exceptions : 5 classes (ErreurFormation, ErreurSupportCommunication, etc.) toutes extends ErreurMetier + this.name + captureStackTrace
Formation entite : versObjetPlain() + versObjetPlainPublic() presentes
Domain/schemas : constantes string uniquement
ServiceValidationFormations present
Handlers : extends BaseActionHandler (tous)
Routes : 2 fichiers (formations.module.routes.ts + sensibilisation.module.routes.ts) — les routes statiques sont avant les dynamiques dans formations.module.routes.ts
2 ModuleControllers : FormationsModuleController + SensibilisationModuleController
Regle 7, 22, 1 : conformes

Warnings¶

W1 : Formations contient des routes de sensibilisation (DistributionSupport, SupportCom, EmissionRadio, EducateurPair) fusionnees dans le module Formations. Architecturalement ce pourrait etre un module separe, mais la fusion est acceptable comme choix technique.

8. ImportExcel — CONFORME¶

Points conformes¶

Structure 5 couches (module specialise : 1 use case)
Exceptions : ErreurImportExcel extends ErreurMetier + this.name + captureStackTrace
Entite RapportImport : versObjetPlain() presente
ServiceValidationImportExcel present
Handler : ImporterFichierExcelHandler extends BaseActionHandler
DI : ImportExcelModule
Routes : import-excel.module.routes.ts
Service domaine : IExcelParserService + ExcelParserService (architecture propre)
Regle 7, 22, 1 : conformes

9. Insertion — CONFORME¶

Points conformes¶

Structure 5 couches complete (6 use cases : Creer, Lister, Obtenir, Modifier, Supprimer, ChangerStatut)
Exceptions : ErreurInsertion extends ErreurMetier + this.name + captureStackTrace
Entite ParcoursInsertion : versObjetPlain() + versObjetPlainPublic() implementees
Interfaces use case : CodeErreur type union, executer(), succes + message
Pattern 5 etapes : validerAvecReglesMetier + executerLogique + auditer + construireResultat + gererErreur
Repos Prisma : updateMany + deleteMany + idUtilisateur dans WHERE
ServiceValidationInsertion present
Handlers : extends BaseActionHandler
DI : InsertionModule extends DIModule
Regle 7, 22, 1 : conformes

Warnings¶

W1 : L'etape audit dans CreerParcoursInsertionUseCase est presente mais simplified (await this.auditer(donnees, { succes: true })) — le repository d'audit n'est pas injecte, l'audit se fait via logger. Fonctionnellement correct (non-bloquant), mais manque de traçabilite persistante.

10. MaitresCoraniques — CONFORME¶

Points conformes¶

Structure 5 couches complete
Exceptions : ErreurMaitreCoranique extends ErreurMetier + this.name + captureStackTrace
Entite MaitreCoranique : versObjetPlain() + versObjetPlainPublic() implementees
Interfaces use case : executer(), succes + message, CodeErreur type union, idUtilisateur
ServiceValidationMaitresCoraniques present
Handlers : extends BaseActionHandler
Repos : updateMany/deleteMany + idUtilisateur + mapper()
DI : MaitresCoraniqueModule
Routes : maitres-coraniques.module.routes.ts avec routes statiques avant dynamiques
Regle 7, 22, 1, 21 : conformes

Warnings¶

W1 : Imports relatifs (../../) dans quelques fichiers handlers — la majorite utilise @/ mais quelques imports internes au module utilisent des chemins relatifs (acceptable pour imports intra-module).

11. Mobilisation — PARTIEL¶

Violations critiques¶

VIOLATION Regle 13 (Etape 3 manquante) — Les use cases du module Mobilisation (CreerComiteUseCase, CreerReunionUseCase, etc.) ne contiennent PAS d'etape d'audit (auditer() absent). Le pattern 5 etapes est reduit a 4 etapes : validation + executerLogique + construireResultat + gererErreur. L'etape audit non-bloquante est absente de tous les use cases Mobilisation.
VIOLATION Regle 4 (CodeErreur type libre) — Dans MobilisationDTO.ts, les interfaces ResultatCreerComite, ResultatModifierComite, etc. utilisent code?: string (string libre) au lieu d'un type union CodeErreurXxx. Cela viole la regle 4 qui impose CodeErreurXxx comme union type TypeScript.

Points conformes¶

Structure 5 couches tres complete (7 entites, 7 repositories, 29 use cases)
Exceptions : ErreurMobilisation extends ErreurMetier + this.name + captureStackTrace
Entites domain : ComiteVillageois, CadreConcertation, etc. avec logique metier (peutTransitionnerVers, etc.)
Interfaces use case : executer() correct, succes + message presents
ServiceValidationMobilisation present
Handlers : extends BaseActionHandler
DI : MobilisationModule extends DIModule
Routes : mobilisation.module.routes.ts
Regle 7, 22, 1 : conformes

Warnings¶

W1 : Les entites (ComiteVillageois, MembreComite, etc.) n'implementent pas versObjetPlain() ni versObjetPlainPublic() — les use cases utilisent directement les DTOs issus des repositories, court-circuitant la couche entite pour la serialisation.

12. Parents — PARTIEL¶

Violations critiques¶

VIOLATION Regle E (update sans Many + absence idUtilisateur) — ParentRepositoryPrisma.ts utilise .update() et .delete() (pas .updateMany() / .deleteMany()) et les WHERE ne contiennent pas idUtilisateur. Le module Parents est non-multi-tenant (comme documente dans les commits), mais la violation de la regle updateMany reste formellement critique selon le guide (regle 12 phase 5).

Points conformes¶

Structure 5 couches complete (6 use cases dont AssocierEnfantParent)
Exceptions : ErreurParent extends ErreurMetier + this.name + captureStackTrace
Entite Parent : versObjetPlainPublic() implementee
Interfaces use case : executer(), succes + message, CodeErreur, idUtilisateur absent (justifie non-multi-tenant)
ServiceValidationParents present
Handlers : extends BaseActionHandler
DI : ParentsModule extends DIModule
Regle 7, 22, 1 : conformes

13. Pilotage — PARTIEL¶

Violations critiques¶

VIOLATION Regle 13 (Etape 3 manquante) — Aucun use case du module Pilotage (CreerEtudeUseCase, CreerIndicateurUseCase, SaisirMesureUseCase, etc.) ne contient d'etape auditer(). L'etape 3 est totalement absente du module. Les 13 use cases ont seulement 4 etapes : validation + executerLogique + construireResultat + gererErreur.

Points conformes¶

Structure 5 couches complete (3 entites : EtudeDiagnostique, IndicateurSuivi, MesureIndicateur)
Exceptions : ErreurPilotage extends ErreurMetier + this.name + captureStackTrace
Entites : versObjetPlain() + versObjetPlainPublic() implementees
CodeErreurPilotage : type union present dans PilotageDTO.ts
Interfaces use case : executer(), succes + message, CodeErreurPilotage
ServiceValidationPilotage present
Repos Prisma : mapper() prive present + idUtilisateur dans WHERE
Handlers : extends BaseActionHandler
DI : PilotageModule extends DIModule
Routes : pilotage.module.routes.ts
Regle 7, 22, 1 : conformes

Warnings¶

W1 : IndicateurSuivi.versObjetPlainPublic() retourne PropsIndicateurSuivi complet avec idUtilisateur inclus — la methode publique ne filtre pas les champs sensibles, ce qui est contraire a l'esprit de la regle 14.

14. Rapports — CONFORME¶

Points conformes¶

Structure 5 couches complete (module lecture seule : 7 use cases)
Exceptions : ErreurRapports extends ErreurMetier + this.name + captureStackTrace
Entite TableauDeBord : versObjetPlainPublic() implementee (+ versObjetPlain() qui delegue a versObjetPlainPublic)
Interfaces use case : executer(), succes + message, CodeErreur
ServiceValidationRapports present
Handlers : extends BaseActionHandler
DI : RapportsModule extends DIModule
Routes : rapports.module.routes.ts
Module non-multi-tenant justifie (rapports globaux pas filtres par user)
Regle 7, 22, 1 : conformes

Warnings¶

W1 : Module lecture seule — pas de updateMany/deleteMany necessaires mais l'absence d'ecriture signifie que certains aspects multi-tenant ne s'appliquent pas.

15. Referentiels — PARTIEL¶

Violations critiques¶

VIOLATION Regle E (update/delete sans Many) — Plusieurs repositories Prisma des Referentiels utilisent .update() et .delete() sans Many : CommuneRepositoryPrisma, TypeAccompagnementRepositoryPrisma, ProfilUtilisateurRepositoryPrisma, PersonneRessourceRepositoryPrisma. Aucun WHERE par idUtilisateur. Module non-multi-tenant (referentiels globaux), mais le guide impose formellement updateMany/deleteMany pour tous les modules.

Points conformes¶

Structure 5 couches complete (5 repositories, 22 use cases)
Exceptions : ErreurReferentiels extends ErreurMetier + this.name + captureStackTrace
Pas d'entite domain (modules referentiel = donnees de configuration) — acceptable
Interfaces use case : executer(), succes + message, CodeErreur type union
ServiceValidationReferentiels present
Handlers : extends BaseActionHandler
DI : ReferentielsModule extends DIModule
Routes : referentiels.module.routes.ts
Regle 7, 22, 1 : conformes

16. Synchronisation — CONFORME¶

Points conformes¶

Structure 5 couches complete (module specialise : 2 use cases)
Exceptions : ErreurSynchronisation extends ErreurMetier + this.name + captureStackTrace
Entite ResultatSync : versObjetPlainPublic() implementee (versObjetPlain() delegue vers versObjetPlainPublic)
Interfaces use case : executer(), succes + message
ServiceValidationSynchronisation present
Handler : extends BaseActionHandler
DI : SynchronisationModule extends DIModule
Routes : synchronisation.module.routes.ts
Regle 7, 22, 1 : conformes

Warnings¶

W1 : idUtilisateur present dans les repos (multi-tenant) mais les use case interfaces peuvent ne pas inclure l'idUtilisateur explicitement dans les Donnees — a verifier selon la nature de la synchronisation.

17. Tuteurs — CONFORME¶

Points conformes¶

Structure 5 couches complete
Exceptions : ErreurTuteur extends ErreurMetier + this.name + captureStackTrace
Entite Tuteur : versObjetPlain() + versObjetPlainPublic() implementees
Interfaces use case : executer(), succes + message, CodeErreur type union
ServiceValidationTuteurs present
Handlers : extends BaseActionHandler
Repos : updateMany/deleteMany + mapper()
DI : TuteursModule extends DIModule
Routes : tuteurs.module.routes.ts
Regle 7, 22, 1 : conformes

Warnings¶

W1 : Meme pattern potential de violation regle 14 (executerLogique peut retourner DTO vs entite) — a verifier dans CreerTuteurUseCase.

Points de conformite globaux (toutes regle OK sur 17 modules)¶

Regle	Description	Statut global
Regle 1	PrismaClient absent couche application	OK 17/17
Regle 2	Entites sans dependances externes	OK
Regle 3	Methode executer() (pas execute/run/process)	OK 17/17
Regle 4	ResultatXxx avec succes + message	OK 17/17 (sauf Mobilisation code?: string)
Regle 5	Exceptions extends ErreurMetier	OK 17/17
Regle 7	z.string().uuid() absent	OK 17/17
Regle 10	this.name dans exceptions	OK 17/17
Regle 11	Error.captureStackTrace dans exceptions	OK 17/17
Regle 15	Routes statiques avant dynamiques	OK 16/17 (Auth routes mal placees)
Regle 18	Arrow functions ModuleController	OK 17/17
Regle 22	.then() absent	OK 17/17
Regle 24-26	Regles environnement	Non verificable par grep

Liste consolidee des violations critiques (regles absolues)¶

Auth — Regle Architecture Routes : auth.module.routes.ts dans shared/infrastructure/http/routes/ au lieu de Modules/Auth/infrastructure/http/routes/. Correction : deplacer vers BackEnd/src/Modules/Auth/infrastructure/http/routes/auth.module.routes.ts.
Auth — Guide Phase 1 Regle 7 : IServiceValidation dupliquee en local (Auth/domain/interfaces/services/) et en shared. Le guide dit "une seule fois pour tout le projet". Correction : supprimer la copie locale et importer depuis @/shared/domain/interfaces/services/IServiceValidation.
Enfants — Regle 14 : construireResultat() dans CreerEnfantUseCase, ModifierEnfantUseCase ne reçoit pas une entite domain mais le DTO direct du repository. La methode ne peut donc pas appeler enfant.versObjetPlainPublic(). Correction : faire retourner executerLogique() l'entite Enfant, puis construireResultat() appelle entite.versObjetPlainPublic().
Mobilisation — Regle 13 : Etape 3 (audit non-bloquant) totalement absente de tous les 29 use cases. Correction : ajouter private async auditer() avec try/catch separe dans chaque use case.
Mobilisation — Regle 4 : code?: string (libre) dans tous les ResultatXxx de MobilisationDTO.ts. Correction : definir export type CodeErreurXxx = 'DONNEES_INVALIDES' | 'ERREUR_SERVEUR' | ... pour chaque action et remplacer code?: string par code?: CodeErreurXxx.
Parents — Regle E (Phase 5) : .update() et .delete() sans Many dans ParentRepositoryPrisma, sans filtre idUtilisateur. Correction : migrer vers .updateMany() / .deleteMany() avec where: { id } (ou ajouter idUtilisateur si le module redevient multi-tenant).
Pilotage — Regle 13 : Etape 3 (audit non-bloquant) totalement absente de tous les 13 use cases. Correction identique a Mobilisation.
Referentiels — Regle E (Phase 5) : .update() / .delete() sans Many dans 4 repositories Prisma (Commune, TypeAccompagnement, ProfilUtilisateur, PersonneRessource). Correction : migrer vers updateMany/deleteMany.

Recommandations par priorite¶

P1 — Critiques (impacts architecture et securite)¶

Redeplacer auth.module.routes.ts vers Modules/Auth/infrastructure/http/routes/ pour respecter l'encapsulation modulaire. Mettre a jour AutoDiscoveryModular.ts pour scanner le bon chemin.
Supprimer IServiceValidation local Auth et importer depuis @/shared/domain/interfaces/services/IServiceValidation. Mettre a jour toutes les references dans Auth.
Ajouter l'etape audit (etape 3) dans tous les use cases de Mobilisation (29 use cases) et Pilotage (13 use cases). Injecter un IAuditLogRepository ou ILogger pour l'audit non-bloquant.

P2 — Importantes (bonne pratique DDD)¶

Corriger la regle 14 dans Enfants : refactoriser executerLogique() pour retourner l'entite domain, et construireResultat() pour appeler versObjetPlainPublic(). Affecter les 3 use cases principaux.
Remplacer code?: string par CodeErreur type union dans tous les Resultat de MobilisationDTO.ts (creations, modifications, suppressions, etc.).

P3 — Conformite (patterns)¶

Migrer update/delete vers updateMany/deleteMany dans ParentRepositoryPrisma (2 methodes) et les 4 repositories Referentiels.

P4 — Nettoyage (dette technique)¶

Supprimer InscrireUtilisateur.ts (fichier de re-export redondant dans Auth/application/usecases/).
Filtrer idUtilisateur dans IndicateurSuivi.versObjetPlainPublic() (Pilotage) — la methode publique expose un champ interne.
Ajouter versObjetPlain() + versObjetPlainPublic() aux entites Mobilisation qui en sont depourvues (ComiteVillageois, MembreComite, CadreConcertation, etc.).

Bilan positif¶

Le socle DDD est tres solide sur l'ensemble du projet : - 17/17 modules : aucune violation des regles 1, 3, 5, 7, 22 (les plus critiques) - 17/17 modules : exceptions correctement typees (ErreurMetier + this.name + captureStackTrace) - 17/17 modules : methode executer() (jamais execute/run/process) - 17/17 modules : PrismaClient absent de la couche application - 17/17 modules : aucun .then() ni z.string().uuid() - Architecture auto-discovery pleinement en place - BaseActionHandler respecte dans tous les handlers - ServiceValidation par module present partout