Générateur de Documentation de Workflow de Projet

Variables de Configuration

${PROJECT_TYPE="Auto-detect|.NET|Java|Spring|Node.js|Python|React|Angular|Microservices|Other"}
<!-- Pile technologique principale -->

${ENTRY_POINT="API|GraphQL|Frontend|CLI|Message Consumer|Scheduled Job|Custom"}
<!-- Point de départ du flux -->

${PERSISTENCE_TYPE="Auto-detect|SQL Database|NoSQL Database|File System|External API|Message Queue|Cache|None"}
<!-- Type de stockage des données -->

${ARCHITECTURE_PATTERN="Auto-detect|Layered|Clean|CQRS|Microservices|MVC|MVVM|Serverless|Event-Driven|Other"}
<!-- Modèle d'architecture principal -->

${WORKFLOW_COUNT=1-5}
<!-- Nombre de workflows à documenter -->

${DETAIL_LEVEL="Standard|Implementation-Ready"}
<!-- Niveau de détail d'implémentation à inclure -->

${INCLUDE_SEQUENCE_DIAGRAM=true|false}
<!-- Générer un diagramme de séquence -->

${INCLUDE_TEST_PATTERNS=true|false}
<!-- Inclure l'approche de test -->

Prompt Généré

"Analysez la base de code et documentez ${WORKFLOW_COUNT} workflows bout en bout représentatifs 
qui peuvent servir de modèles d'implémentation pour des fonctionnalités similaires. Utilisez l'approche suivante :

Phase de Détection Initiale

${PROJECT_TYPE == "Auto-detect" ? 
  "Commencez par examiner la structure de la base de code pour identifier les technologies :
   - Vérifiez les solutions/projets .NET, les configurations Spring, les fichiers Node.js/Express, etc.
   - Identifiez le(s) langage(s) de programmation et framework(s) principal(aux) en usage
   - Déterminez les modèles architecturaux en fonction de la structure des dossiers et des composants clés" 
  : "Concentrez-vous sur les modèles et conventions ${PROJECT_TYPE}"}

${ENTRY_POINT == "Auto-detect" ? 
  "Identifiez les points d'entrée typiques en cherchant :
   - Les contrôleurs API ou définitions de routes
   - Les résolveurs GraphQL
   - Les composants UI qui initialisent les demandes réseau
   - Les gestionnaires de messages ou souscripteurs d'événements
   - Les définitions de travaux programmés" 
  : "Concentrez-vous sur les points d'entrée ${ENTRY_POINT}"}

${PERSISTENCE_TYPE == "Auto-detect" ? 
  "Déterminez les mécanismes de persistance en examinant :
   - Les configurations de contexte/connexion de base de données
   - Les implémentations de dépôt
   - Les mappages ORM
   - Les clients API externes
   - Les interactions avec le système de fichiers" 
  : "Concentrez-vous sur les interactions ${PERSISTENCE_TYPE}"}

Instructions de Documentation de Workflow

Pour chacun des ${WORKFLOW_COUNT} workflow(s) les plus représentatif(s) du système :

1. Aperçu du Workflow

Fournissez un nom et une brève description du workflow
Expliquez l'objectif métier qu'il sert
Identifiez l'action ou l'événement déclencheur
Listez tous les fichiers/classes impliqués dans le workflow complet

2. Implémentation du Point d'Entrée

Points d'Entrée API :

${ENTRY_POINT == "API" || ENTRY_POINT == "Auto-detect" ? 
  "- Documentez la classe contrôleur et la méthode API qui reçoit la demande
   - Montrez la signature de méthode complète incluant les attributs/annotations
   - Incluez la définition complète de la classe DTO/modèle de demande
   - Documentez les attributs de validation et les validateurs personnalisés
   - Montrez les attributs d'authentification/autorisation et les vérifications" : ""}

Points d'Entrée GraphQL :

${ENTRY_POINT == "GraphQL" || ENTRY_POINT == "Auto-detect" ? 
  "- Documentez la classe résolveur et la méthode GraphQL
   - Montrez la définition complète du schéma pour la requête/mutation
   - Incluez les définitions de type d'entrée
   - Montrez l'implémentation de la méthode résolveur avec gestion des paramètres" : ""}

Points d'Entrée Frontend :

${ENTRY_POINT == "Frontend" || ENTRY_POINT == "Auto-detect" ? 
  "- Documentez le composant qui initie l'appel API
   - Montrez le gestionnaire d'événement qui déclenche la demande
   - Incluez la méthode du service client API
   - Montrez le code de gestion d'état lié à la demande" : ""}

Points d'Entrée Message Consumer :

${ENTRY_POINT == "Message Consumer" || ENTRY_POINT == "Auto-detect" ? 
  "- Documentez la classe gestionnaire de messages et la méthode
   - Montrez la configuration de souscription aux messages
   - Incluez la définition complète du modèle de message
   - Montrez la logique de désérialisation et de validation" : ""}

3. Implémentation de la Couche Service

Documentez chaque classe de service impliquée avec ses dépendances
Montrez les signatures de méthode complètes avec paramètres et types de retour
Incluez les implémentations de méthode réelles avec la logique métier clé
Documentez les définitions d'interface où applicable
Montrez les modèles d'enregistrement d'injection de dépendances

Modèles CQRS :

${ARCHITECTURE_PATTERN == "CQRS" || ARCHITECTURE_PATTERN == "Auto-detect" ? 
  "- Incluez les implémentations complètes des gestionnaires de commande/requête" : ""}

Modèles Clean Architecture :

${ARCHITECTURE_PATTERN == "Clean" || ARCHITECTURE_PATTERN == "Auto-detect" ? 
  "- Montrez les implémentations de cas d'usage/interacteur" : ""}

4. Modèles de Mappage de Données

Documentez le code de mappage DTO vers modèle de domaine
Montrez les configurations de mappeur d'objet ou les méthodes de mappage manuel
Incluez la logique de validation lors du mappage
Documentez tous les événements de domaine créés lors du mappage

5. Implémentation de l'Accès aux Données

Documentez les interfaces de dépôt et leurs implémentations
Montrez les signatures de méthode complètes avec paramètres et types de retour
Incluez les implémentations de requête réelles
Documentez les définitions de classe d'entité/modèle avec toutes les propriétés
Montrez les modèles de gestion des transactions

Modèles de Base de Données SQL :

${PERSISTENCE_TYPE == "SQL Database" || PERSISTENCE_TYPE == "Auto-detect" ? 
  "- Incluez les configurations ORM, les annotations ou l'utilisation de Fluent API
   - Montrez les requêtes SQL réelles ou les déclarations ORM" : ""}

Modèles de Base de Données NoSQL :

${PERSISTENCE_TYPE == "NoSQL Database" || PERSISTENCE_TYPE == "Auto-detect" ? 
  "- Montrez les définitions de structure de document
   - Incluez les opérations de requête/mise à jour de document" : ""}

6. Construction de la Réponse

Documentez les définitions de classe DTO/modèle de réponse
Montrez le mappage des modèles de domaine/entité vers les modèles de réponse
Incluez la logique de sélection du code de statut
Documentez la structure et la génération des réponses d'erreur

7. Modèles de Gestion d'Erreurs

Documentez les types d'exception utilisés dans le workflow
Montrez les modèles try/catch à chaque couche
Incluez les configurations du gestionnaire d'exceptions global
Documentez les implémentations de journalisation d'erreurs
Montrez les politiques de nouvelle tentative ou les modèles disjoncteur
Incluez les actions compensatoires pour les scénarios d'échec

8. Modèles de Traitement Asynchrone

Documentez le code de programmation de travail en arrière-plan
Montrez les implémentations de publication d'événement
Incluez les modèles d'envoi de file d'attente de messages
Documentez les implémentations de rappel ou webhook
Montrez comment les opérations asynchrones sont suivies et surveillées

Approche de Test (Optionnel) :

${INCLUDE_TEST_PATTERNS ? 
  "9. **Approche de Test**
     - Documentez les implémentations de test unitaire pour chaque couche
     - Montrez les modèles de simulation et la configuration des fixtures de test
     - Incluez les implémentations de test d'intégration
     - Documentez les approches de génération de données de test
     - Montrez les implémentations de test API/contrôleur" : ""}

Diagramme de Séquence (Optionnel) :

${INCLUDE_SEQUENCE_DIAGRAM ? 
  "10. **Diagramme de Séquence**
      - Générez un diagramme de séquence détaillé montrant tous les composants
      - Incluez les appels de méthode avec les types de paramètres
      - Montrez les valeurs de retour entre les composants
      - Documentez les flux conditionnels et les chemins d'erreur" : ""}

11. Conventions de Nommage

Documentez les modèles cohérents pour :

Nommage des contrôleurs (ex. : EntityNameController)
Nommage des services (ex. : EntityNameService)
Nommage des dépôts (ex. : IEntityNameRepository)
Nommage des DTO (ex. : EntityNameRequest, EntityNameResponse)
Modèles de nommage des méthodes pour les opérations CRUD
Conventions de nommage des variables
Modèles d'organisation des fichiers

12. Modèles d'Implémentation

Fournissez des modèles de code réutilisables pour :

Créer un nouveau point de terminaison API suivant le modèle
Implémenter une nouvelle méthode de service
Ajouter une nouvelle méthode de dépôt
Créer de nouvelles classes de modèle de domaine
Implémenter une gestion d'erreurs appropriée

Modèles d'Implémentation Spécifiques à la Technologie

Modèles d'Implémentation .NET (si détectés) :

${PROJECT_TYPE == ".NET" || PROJECT_TYPE == "Auto-detect" ? 
  "- Classe contrôleur complète avec attributs, filtres et injection de dépendances
   - Enregistrement du service dans Startup.cs ou Program.cs
   - Configuration de DbContext Entity Framework
   - Implémentation de dépôt avec EF Core ou Dapper
   - Configurations de profil AutoMapper
   - Implémentations de middleware pour les préoccupations transversales
   - Modèles de méthodes d'extension
   - Implémentation du modèle Options pour la configuration
   - Implémentation de journalisation avec ILogger
   - Implémentations de filtre d'authentification/autorisation ou de politique" : ""}

Modèles d'Implémentation Spring (si détectés) :

${PROJECT_TYPE == "Java" || PROJECT_TYPE == "Spring" || PROJECT_TYPE == "Auto-detect" ? 
  "- Classe contrôleur complète avec annotations et injection de dépendances
   - Implémentation de service avec limites de transaction
   - Interface de dépôt et implémentation
   - Définitions d'entité JPA avec relations
   - Implémentations de classe DTO
   - Configuration de bean et balayage de composant
   - Implémentations de gestionnaire d'exceptions
   - Implémentations de validateur personnalisé" : ""}

Modèles d'Implémentation React (si détectés) :

${PROJECT_TYPE == "React" || PROJECT_TYPE == "Auto-detect" ? 
  "- Structure de composant avec props et état
   - Modèles d'implémentation Hook (useState, useEffect, hooks personnalisés)
   - Implémentation du service API
   - Modèles de gestion d'état (Context, Redux)
   - Implémentations de gestion de formulaire
   - Configuration de route" : ""}

Directives d'Implémentation

En fonction des workflows documentés, fournissez des directives spécifiques pour implémenter de nouvelles fonctionnalités :

1. Processus d'Implémentation Étape par Étape

Où commencer lors de l'ajout d'une fonctionnalité similaire
Ordre d'implémentation (ex. : modèle → dépôt → service → contrôleur)
Comment s'intégrer aux préoccupations transversales existantes

2. Pièges Courants à Éviter

Identifiez les zones sujettes aux erreurs dans l'implémentation actuelle
Notez les considérations de performance
Listez les bogues courants ou les problèmes rencontrés

3. Mécanismes d'Extension

Documentez comment vous connecter aux points d'extension existants
Montrez comment ajouter un nouveau comportement sans modifier le code existant
Expliquez les modèles de fonctionnalités pilotées par configuration

Conclusion : Concluez avec un résumé des modèles les plus importants qui doivent être suivis lors de l'implémentation de nouvelles fonctionnalités pour maintenir la cohérence avec la base de code."

project-workflow-analysis-blueprint-generator