Générer une application à partir d'une spécification OpenAPI

Votre objectif est de générer une application complète et fonctionnelle à partir d'une spécification OpenAPI en utilisant les conventions et les meilleures pratiques du framework actif.

Exigences d'entrée

1. Spécification OpenAPI : Fournissez l'une des options suivantes :

   • Une URL vers la spécification OpenAPI (par exemple, https://api.example.com/openapi.json)
   • Un chemin de fichier local vers la spécification OpenAPI
   • Le contenu complet de la spécification OpenAPI collé directement

2. Détails du projet (s'ils ne figurent pas dans la spécification) :

   • Nom et description du projet
   • Framework cible et version
   • Conventions de nommage des packages/namespaces
   • Méthode d'authentification (si non spécifiée dans OpenAPI)

Processus de génération

Étape 1 : Analyser la spécification OpenAPI

• Valider la spécification OpenAPI pour l'exhaustivité et l'exactitude
• Identifier tous les points de terminaison, méthodes HTTP, schémas de requête/réponse
• Extraire les exigences d'authentification et les schémas de sécurité
• Noter les relations et contraintes des modèles de données
• Signaler les ambiguïtés ou définitions incomplètes

Étape 2 : Concevoir l'architecture de l'application

• Planifier la structure des répertoires appropriée pour le framework
• Identifier le regroupement des contrôleurs/handlers par ressource ou domaine
• Concevoir l'organisation de la couche service pour la logique métier
• Planifier les modèles de données et les relations entre entités
• Concevoir la stratégie de configuration et d'initialisation

Étape 3 : Générer le code de l'application

• Créer la structure du projet avec les fichiers de configuration de build/package
• Générer les modèles/DTOs à partir des schémas OpenAPI
• Générer les contrôleurs/handlers avec les mappages de routes
• Générer la couche service avec la logique métier
• Générer la couche repository/accès aux données si applicable
• Ajouter la gestion des erreurs, la validation et la journalisation
• Générer le code de configuration et de démarrage

Étape 4 : Ajouter les fichiers de support

• Générer les tests unitaires appropriés pour les services et contrôleurs
• Créer un README avec les instructions de configuration et d'exécution
• Ajouter les modèles .gitignore et configuration d'environnement
• Générer les fichiers de documentation API
• Créer des requêtes d'exemple/tests d'intégration

Structure de sortie

L'application générée inclura :

project-name/
├── README.md                      # Instructions de configuration et d'utilisation
├── [build-config]                 # Fichiers de build spécifiques au framework (pom.xml, build.gradle, package.json, etc.)
├── src/
│   ├── main/
│   │   ├── [language]/
│   │   │   ├── controllers/       # Gestionnaires de points de terminaison HTTP
│   │   │   ├── services/          # Logique métier
│   │   │   ├── models/            # Modèles de données et DTOs
│   │   │   ├── repositories/      # Accès aux données (si applicable)
│   │   │   └── config/            # Configuration de l'application
│   │   └── resources/             # Fichiers de configuration
│   └── test/
│       ├── [language]/
│       │   ├── controllers/       # Tests des contrôleurs
│       │   └── services/          # Tests des services
│       └── resources/             # Configuration des tests
├── .gitignore
├── .env.example                   # Modèle de variables d'environnement
└── docker-compose.yml             # Optionnel : configuration Docker (si applicable)

Meilleures pratiques appliquées

• Conventions du framework : Suit les conventions, structures et patterns spécifiques au framework
• Séparation des préoccupations : Couches claires avec contrôleurs, services et repositories
• Gestion des erreurs : Gestion complète des erreurs avec réponses significatives
• Validation : Validation des entrées et validation de schéma tout au long de l'application
• Journalisation : Journalisation structurée pour le débogage et la surveillance
• Tests : Tests unitaires pour les services et contrôleurs
• Documentation : Documentation du code inline et instructions de configuration
• Sécurité : Implémente l'authentification/autorisation à partir de la spécification OpenAPI
• Scalabilité : Les patterns de conception supportent la croissance et la maintenance

Prochaines étapes

Après la génération :

1. Examinez la structure du code généré et personnalisez-la selon vos besoins
2. Installez les dépendances selon les exigences du framework
3. Configurez les variables d'environnement et les connexions aux bases de données
4. Exécutez les tests pour vérifier le code généré
5. Démarrez le serveur de développement
6. Testez les points de terminaison en utilisant les exemples fournis

Questions à poser si nécessaire

• L'application doit-elle inclure la configuration de base de données/ORM, ou seulement des données en mémoire/mock ?
• Voulez-vous une configuration Docker pour la conteneurisation ?
• L'authentification doit-elle être JWT, OAuth2, clés API, ou authentification basique ?
• Avez-vous besoin de tests d'intégration ou seulement de tests unitaires ?
• Des préférences technologiques spécifiques pour la base de données ?
• L'API doit-elle inclure des exemples de pagination, filtrage et tri ?